_ZN4args14ArgumentParserC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 3415|    972|            {
 3416|    972|                Description(description_);
 3417|    972|                Epilog(epilog_);
 3418|    972|                LongPrefix("--");
 3419|    972|                ShortPrefix("-");
 3420|    972|                LongSeparator("=");
 3421|    972|                Terminator("--");
 3422|    972|                SetArgumentSeparations(true, true, true, true);
 3423|    972|                matched = true;
 3424|    972|            }
_ZN4args7CommandC2Ev:
 2231|    972|            Command() = default;
_ZN4args5GroupC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_8functionIFbRKS0_EEENS_7OptionsE:
 1715|    972|            Group(const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_)
 1716|    972|            {
 1717|    972|                parent = nullptr;
 1718|    972|            }
_ZN4args4BaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7OptionsE:
 1024|  3.88k|            Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
_ZNK4args4Base7MatchedEv:
 1038|  13.0k|            {
 1039|  13.0k|                return matched;
 1040|  13.0k|            }
_ZN4args4Base11GetCommandsEv:
 1060|  2.91k|            {
 1061|  2.91k|                return {};
 1062|  2.91k|            }
_ZNK4args4Base7IsGroupEv:
 1065|     66|            {
 1066|     66|                return false;
 1067|     66|            }
_ZN4args4Base17GetNextPositionalEv:
 1080|    741|            {
 1081|    741|                return nullptr;
 1082|    741|            }
_ZNK4args4Base10HasCommandEv:
 1100|     66|            {
 1101|     66|                return false;
 1102|     66|            }
_ZN4args4Base5ResetEv:
 1129|  3.88k|            {
 1130|  3.88k|                matched = false;
 1131|       |#ifdef ARGS_NOEXCEPT
 1132|       |                error = Error::None;
 1133|       |                errorMsg.clear();
 1134|       |#endif
 1135|  3.88k|            }
_ZN4args4BaseD2Ev:
 1025|  3.88k|            virtual ~Base() {}
_ZN4args5GroupD2Ev:
 1725|    972|            virtual ~Group() {}
_ZNK4args5Group8ChildrenEv:
 1758|  16.9k|            {
 1759|  16.9k|                return children;
 1760|  16.9k|            }
_ZN4argsanENS_7OptionsES0_:
  809|  22.1k|    {
  810|  22.1k|        return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
  811|  22.1k|    }
_ZNK4args4Base10GetOptionsEv:
 1028|  11.0k|            {
 1029|  11.0k|                return options;
 1030|  11.0k|            }
_ZN4args5Group11GetCommandsEv:
 1951|    972|            {
 1952|    972|                std::vector<Command*> res;
 1953|    972|                for (const auto &child : Children())
  ------------------
  |  Branch (1953:40): [True: 2.91k, False: 972]
  ------------------
 1954|  2.91k|                {
 1955|  2.91k|                    auto subparsers = child->GetCommands();
 1956|  2.91k|                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
 1957|  2.91k|                }
 1958|    972|                return res;
 1959|    972|            }
_ZN4args5Group5MatchERKNS_10EitherFlagE:
 1768|  11.7k|            {
 1769|  11.7k|                for (Base *child: Children())
  ------------------
  |  Branch (1769:33): [True: 33.4k, False: 666]
  ------------------
 1770|  33.4k|                {
 1771|  33.4k|                    if (FlagBase *match = child->Match(flag))
  ------------------
  |  Branch (1771:35): [True: 11.0k, False: 22.3k]
  ------------------
 1772|  11.0k|                    {
 1773|  11.0k|                        return match;
 1774|  11.0k|                    }
 1775|  33.4k|                }
 1776|    666|                return nullptr;
 1777|  11.7k|            }
_ZN4args5Group17GetNextPositionalEv:
 1803|    247|            {
 1804|    247|                for (Base *child: Children())
  ------------------
  |  Branch (1804:33): [True: 741, False: 247]
  ------------------
 1805|    741|                {
 1806|    741|                    if (auto next = child->GetNextPositional())
  ------------------
  |  Branch (1806:30): [True: 0, False: 741]
  ------------------
 1807|      0|                    {
 1808|      0|                        return next;
 1809|      0|                    }
 1810|    741|                }
 1811|    247|                return nullptr;
 1812|    247|            }
_ZNK4args5Group10HasCommandEv:
 1837|     22|            {
 1838|     22|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
 1839|     22|            }
_ZZNK4args5Group10HasCommandEvENKUlPNS_4BaseEE_clES2_:
 1838|     66|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
_ZN4args5Group5ResetEv:
 1967|    972|            {
 1968|    972|                Base::Reset();
 1969|       |
 1970|    972|                for (auto &child: Children())
  ------------------
  |  Branch (1970:33): [True: 2.91k, False: 972]
  ------------------
 1971|  2.91k|                {
 1972|  2.91k|                    child->Reset();
 1973|  2.91k|                }
 1974|       |#ifdef ARGS_NOEXCEPT
 1975|       |                error = Error::None;
 1976|       |                errorMsg.clear();
 1977|       |#endif
 1978|    972|            }
_ZN4args7Command5ResetEv:
 2683|    972|            {
 2684|    972|                Group::Reset();
 2685|    972|                selectedCommand = nullptr;
 2686|    972|                subparserProgramLine.clear();
 2687|    972|                subparserDescription.clear();
 2688|    972|                subparserHasFlag = false;
 2689|    972|                subparserHasPositional = false;
 2690|    972|                subparserHasCommand = false;
 2691|       |#ifdef ARGS_NOEXCEPT
 2692|       |                subparserError = Error::None;
 2693|       |#endif
 2694|    972|            }
_ZN4args7Command11DescriptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2304|    972|            { this->description = description_; }
_ZN4args7Command6EpilogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2314|    972|            { this->epilog = epilog_; }
_ZN4args14ArgumentParser10LongPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3451|    972|            {
 3452|    972|                this->longprefix = longprefix_;
 3453|    972|                this->helpParams.longPrefix = longprefix_;
 3454|    972|            }
_ZN4args14ArgumentParser11ShortPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3463|    972|            {
 3464|    972|                this->shortprefix = shortprefix_;
 3465|    972|                this->helpParams.shortPrefix = shortprefix_;
 3466|    972|            }
_ZN4args14ArgumentParser13LongSeparatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3475|    972|            {
 3476|    972|                if (longseparator_.empty())
  ------------------
  |  Branch (3476:21): [True: 0, False: 972]
  ------------------
 3477|      0|                {
 3478|      0|                    const std::string errorMessage("longseparator can not be set to empty");
 3479|       |#ifdef ARGS_NOEXCEPT
 3480|       |                    error = Error::Usage;
 3481|       |                    errorMsg = errorMessage;
 3482|       |#else
 3483|      0|                    throw UsageError(errorMessage);
 3484|      0|#endif
 3485|      0|                } else
 3486|    972|                {
 3487|    972|                    this->longseparator = longseparator_;
 3488|    972|                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3488:54): [True: 972, False: 0]
  ------------------
 3489|    972|                }
 3490|    972|            }
_ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  480|    950|            Error(const std::string &problem) : std::runtime_error(problem) {}
_ZN4args14ArgumentParser10TerminatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3499|    972|            { this->terminator = terminator_; }
_ZN4args14ArgumentParser22SetArgumentSeparationsEbbbb:
 3529|    972|            {
 3530|    972|                this->allowJoinedShortValue = allowJoinedShortValue_;
 3531|    972|                this->allowJoinedLongValue = allowJoinedLongValue_;
 3532|    972|                this->allowSeparateShortValue = allowSeparateShortValue_;
 3533|    972|                this->allowSeparateLongValue = allowSeparateLongValue_;
 3534|       |
 3535|    972|                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3535:50): [True: 972, False: 0]
  ------------------
 3536|    972|                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
  ------------------
  |  Branch (3536:51): [True: 972, False: 0]
  ------------------
 3537|    972|            }
_ZNK4args7Command7MatchedEv:
 2337|  12.9k|            { return Base::Matched(); }
_ZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2632|     22|            {
 2633|     22|                if (!Matched())
  ------------------
  |  Branch (2633:21): [True: 0, False: 22]
  ------------------
 2634|      0|                {
 2635|      0|                    return;
 2636|      0|                }
 2637|       |
 2638|     22|                auto onValidationError = [&]
 2639|     22|                {
 2640|     22|                    std::ostringstream problem;
 2641|     22|                    problem << "Group validation failed somewhere!";
 2642|       |#ifdef ARGS_NOEXCEPT
 2643|       |                    error = Error::Validation;
 2644|       |                    errorMsg = problem.str();
 2645|       |#else
 2646|     22|                    throw ValidationError(problem.str());
 2647|     22|#endif
 2648|     22|                };
 2649|       |
 2650|     22|                for (Base *child: Children())
  ------------------
  |  Branch (2650:33): [True: 66, False: 22]
  ------------------
 2651|     66|                {
 2652|     66|                    if (child->IsGroup() && !child->Matched())
  ------------------
  |  Branch (2652:25): [True: 0, False: 66]
  |  Branch (2652:45): [True: 0, False: 0]
  ------------------
 2653|      0|                    {
 2654|      0|                        onValidationError();
 2655|      0|                    }
 2656|       |
 2657|     66|                    child->Validate(shortprefix, longprefix);
 2658|     66|                }
 2659|       |
 2660|     22|                if (subparser != nullptr)
  ------------------
  |  Branch (2660:21): [True: 0, False: 22]
  ------------------
 2661|      0|                {
 2662|      0|                    subparser->Validate(shortprefix, longprefix);
 2663|      0|                    if (!subparser->Matched())
  ------------------
  |  Branch (2663:25): [True: 0, False: 0]
  ------------------
 2664|      0|                    {
 2665|      0|                        onValidationError();
 2666|      0|                    }
 2667|      0|                }
 2668|       |
 2669|     22|                if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
  ------------------
  |  Branch (2669:21): [True: 22, False: 0]
  |  Branch (2669:51): [True: 22, False: 0]
  |  Branch (2669:73): [True: 0, False: 22]
  |  Branch (2669:96): [True: 0, False: 22]
  ------------------
 2670|      0|                {
 2671|      0|                    std::ostringstream problem;
 2672|      0|                    problem << "Command is required";
 2673|       |#ifdef ARGS_NOEXCEPT
 2674|       |                    error = Error::Validation;
 2675|       |                    errorMsg = problem.str();
 2676|       |#else
 2677|      0|                    throw ValidationError(problem.str());
 2678|      0|#endif
 2679|      0|                }
 2680|     22|            }
_ZN4args7Command11GetCommandsEv:
 2535|    972|            {
 2536|    972|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2536:21): [True: 0, False: 972]
  ------------------
 2537|      0|                {
 2538|      0|                    return selectedCommand->GetCommands();
 2539|      0|                }
 2540|       |
 2541|    972|                if (Matched())
  ------------------
  |  Branch (2541:21): [True: 972, False: 0]
  ------------------
 2542|    972|                {
 2543|    972|                    return Group::GetCommands();
 2544|    972|                }
 2545|       |
 2546|      0|                return { this };
 2547|    972|            }
_ZN4args7Command5MatchERKNS_10EitherFlagE:
 2356|  11.7k|            {
 2357|  11.7k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2357:21): [True: 0, False: 11.7k]
  ------------------
 2358|      0|                {
 2359|      0|                    if (auto *res = selectedCommand->Match(flag))
  ------------------
  |  Branch (2359:31): [True: 0, False: 0]
  ------------------
 2360|      0|                    {
 2361|      0|                        return res;
 2362|      0|                    }
 2363|       |
 2364|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (2364:37): [True: 0, False: 0]
  ------------------
 2365|      0|                    {
 2366|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (2366:29): [True: 0, False: 0]
  ------------------
 2367|      0|                        {
 2368|      0|                            if (auto *res = child->Match(flag))
  ------------------
  |  Branch (2368:39): [True: 0, False: 0]
  ------------------
 2369|      0|                            {
 2370|      0|                                return res;
 2371|      0|                            }
 2372|      0|                        }
 2373|      0|                    }
 2374|       |
 2375|      0|                    return nullptr;
 2376|      0|                }
 2377|       |
 2378|  11.7k|                if (subparser != nullptr)
  ------------------
  |  Branch (2378:21): [True: 0, False: 11.7k]
  ------------------
 2379|      0|                {
 2380|      0|                    return subparser->Match(flag);
 2381|      0|                }
 2382|       |
 2383|  11.7k|                return Matched() ? Group::Match(flag) : nullptr;
  ------------------
  |  Branch (2383:24): [True: 11.7k, False: 0]
  ------------------
 2384|  11.7k|            }
_ZN4args7Command17GetNextPositionalEv:
 2420|    247|            {
 2421|    247|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2421:21): [True: 0, False: 247]
  ------------------
 2422|      0|                {
 2423|      0|                    if (auto *res = selectedCommand->GetNextPositional())
  ------------------
  |  Branch (2423:31): [True: 0, False: 0]
  ------------------
 2424|      0|                    {
 2425|      0|                        return res;
 2426|      0|                    }
 2427|       |
 2428|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (2428:37): [True: 0, False: 0]
  ------------------
 2429|      0|                    {
 2430|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (2430:29): [True: 0, False: 0]
  ------------------
 2431|      0|                        {
 2432|      0|                            if (auto *res = child->GetNextPositional())
  ------------------
  |  Branch (2432:39): [True: 0, False: 0]
  ------------------
 2433|      0|                            {
 2434|      0|                                return res;
 2435|      0|                            }
 2436|      0|                        }
 2437|      0|                    }
 2438|       |
 2439|      0|                    return nullptr;
 2440|      0|                }
 2441|       |
 2442|    247|                if (subparser != nullptr)
  ------------------
  |  Branch (2442:21): [True: 0, False: 247]
  ------------------
 2443|      0|                {
 2444|      0|                    return subparser->GetNextPositional();
 2445|      0|                }
 2446|       |
 2447|    247|                return Matched() ? Group::GetNextPositional() : nullptr;
  ------------------
  |  Branch (2447:24): [True: 247, False: 0]
  ------------------
 2448|    247|            }
_ZN4args14ArgumentParser5ResetEv:
 3667|    972|            {
 3668|    972|                Command::Reset();
 3669|    972|                matched = true;
 3670|    972|                readCompletion = false;
 3671|    972|            }
_ZN4args10EitherFlagC2Ec:
  575|  19.9k|        EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
_ZN4args10EitherFlagC2EPKc:
  574|  2.91k|        EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args7MatcherC2ESt16initializer_listINS_10EitherFlagEE:
  680|  2.91k|                Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
_ZN4args10EitherFlag8GetShortESt16initializer_listIS0_E:
  595|  2.91k|        {
  596|  2.91k|            std::unordered_set<char>  shortFlags;
  597|  2.91k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (597:40): [True: 5.83k, False: 2.91k]
  ------------------
  598|  5.83k|            {
  599|  5.83k|                if (flag.isShort)
  ------------------
  |  Branch (599:21): [True: 2.91k, False: 2.91k]
  ------------------
  600|  2.91k|                {
  601|  2.91k|                    shortFlags.insert(flag.shortFlag);
  602|  2.91k|                }
  603|  5.83k|            }
  604|  2.91k|            return shortFlags;
  605|  2.91k|        }
_ZN4args10EitherFlag7GetLongESt16initializer_listIS0_E:
  580|  2.91k|        {
  581|  2.91k|            std::unordered_set<std::string>  longFlags;
  582|  2.91k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (582:40): [True: 5.83k, False: 2.91k]
  ------------------
  583|  5.83k|            {
  584|  5.83k|                if (!flag.isShort)
  ------------------
  |  Branch (584:21): [True: 2.91k, False: 2.91k]
  ------------------
  585|  2.91k|                {
  586|  2.91k|                    longFlags.insert(flag.longFlag);
  587|  2.91k|                }
  588|  5.83k|            }
  589|  2.91k|            return longFlags;
  590|  2.91k|        }
_ZN4args7MatcherC2INSt3__113unordered_setIcNS2_4hashIcEENS2_8equal_toIcEENS2_9allocatorIcEEEENS3_INS2_12basic_stringIcNS2_11char_traitsIcEES9_EENS4_ISE_EENS6_ISE_EENS8_ISE_EEEEEEOT_OT0_:
  664|  2.91k|                Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
  665|  2.91k|            {}
_ZN4args7MatcherC2INSt3__121__hash_const_iteratorIPNS2_11__hash_nodeIcPvEEEENS3_IPNS4_INS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES5_EEEEEET_SI_T0_SJ_:
  639|  2.91k|                shortFlags(shortFlagsStart, shortFlagsEnd),
  640|  2.91k|                longFlags(longFlagsStart, longFlagsEnd)
  641|  2.91k|            {
  642|  2.91k|                if (shortFlags.empty() && longFlags.empty())
  ------------------
  |  Branch (642:21): [True: 0, False: 2.91k]
  |  Branch (642:43): [True: 0, False: 0]
  ------------------
  643|      0|                {
  644|      0|#ifndef ARGS_NOEXCEPT
  645|      0|                    throw UsageError("empty Matcher");
  646|      0|#endif
  647|      0|                }
  648|  2.91k|            }
_ZN4args8HelpFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE:
 3819|    972|            HelpFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_ = {}): Flag(group_, name_, help_, std::move(matcher_), options_) {}
_ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE:
 3784|  2.91k|            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
 3785|  2.91k|            {
 3786|  2.91k|                group_.Add(*this);
 3787|  2.91k|            }
_ZN4args8FlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE:
 1352|  2.91k|            FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : NamedBase(name_, help_, options_), matcher(std::move(matcher_)) {}
_ZN4args9NamedBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_7OptionsE:
 1185|  2.91k|            NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
_ZN4args9NamedBaseD2Ev:
 1186|  2.91k|            virtual ~NamedBase() {}
_ZN4args7MatcherC2EOS0_:
  682|  2.91k|            Matcher(Matcher &&other) noexcept : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
  683|  2.91k|            {}
_ZN4args5Group3AddERNS_4BaseE:
 1730|  2.91k|            {
 1731|  2.91k|                children.emplace_back(&child);
 1732|       |
 1733|  2.91k|                if(child.IsFlag()) {
  ------------------
  |  Branch (1733:20): [True: 2.91k, False: 0]
  ------------------
 1734|  2.91k|#ifndef ARGS_NOEXCEPT
 1735|       |                    // Detection runs from the child's own constructor, so a
 1736|       |                    // duplicate throws before that constructor completes and the
 1737|       |                    // child's storage is released while the stack unwinds. Undo
 1738|       |                    // the registration first, or a caller that catches the error
 1739|       |                    // leaves this group holding a pointer to a dead object.
 1740|  2.91k|                    try
 1741|  2.91k|                    {
 1742|  2.91k|                        SignalDetectDuplicates();
 1743|  2.91k|                    }
 1744|  2.91k|                    catch (...)
 1745|  2.91k|                    {
 1746|      0|                        children.pop_back();
 1747|      0|                        throw;
 1748|      0|                    }
 1749|       |#else
 1750|       |                    SignalDetectDuplicates();
 1751|       |#endif
 1752|  2.91k|                }
 1753|  2.91k|            }
_ZN4args5Group22SignalDetectDuplicatesEv:
 1984|  2.91k|            {
 1985|  2.91k|                if(parent != nullptr) parent->SignalDetectDuplicates();
  ------------------
  |  Branch (1985:20): [True: 0, False: 2.91k]
  ------------------
 1986|  2.91k|                else DetectDuplicateFlags();
 1987|  2.91k|            }
_ZN4args5Group20DetectDuplicateFlagsEv:
 1994|  2.91k|            {
 1995|  2.91k|                std::unordered_set<char> usedShortFlags;
 1996|  2.91k|                std::unordered_set<std::string> usedLongFlags;
 1997|  2.91k|                DetectDuplicateFlags(usedShortFlags, usedLongFlags);
 1998|  2.91k|            }
_ZN4args5Group20DetectDuplicateFlagsERNSt3__113unordered_setIcNS1_4hashIcEENS1_8equal_toIcEENS1_9allocatorIcEEEERNS2_INS1_12basic_stringIcNS1_11char_traitsIcEES8_EENS3_ISE_EENS5_ISE_EENS7_ISE_EEEE:
 2003|  2.91k|            {
 2004|  2.91k|                for (Base *child: Children())
  ------------------
  |  Branch (2004:33): [True: 5.83k, False: 2.91k]
  ------------------
 2005|  5.83k|                {
 2006|  5.83k|                    if(auto flag = dynamic_cast<FlagBase*>(child))
  ------------------
  |  Branch (2006:29): [True: 5.83k, False: 0]
  ------------------
 2007|  5.83k|                    {
 2008|       |                        // Check for duplicate flags, setting a usage error on the
 2009|       |                        // flag if a duplicate is detected.
 2010|  5.83k|                        for(EitherFlag flagString: flag->GetMatcher().GetFlagStrings())
  ------------------
  |  Branch (2010:50): [True: 11.6k, False: 5.83k]
  ------------------
 2011|  11.6k|                        {
 2012|  11.6k|                            if(flagString.isShort)
  ------------------
  |  Branch (2012:32): [True: 5.83k, False: 5.83k]
  ------------------
 2013|  5.83k|                            {
 2014|  5.83k|                                if(usedShortFlags.count(flagString.shortFlag))
  ------------------
  |  Branch (2014:36): [True: 0, False: 5.83k]
  ------------------
 2015|      0|                                {
 2016|       |#ifdef ARGS_NOEXCEPT
 2017|       |                                    flag->SetUsageError();
 2018|       |#else
 2019|      0|                                    throw ParseError("duplicate short flag detected");
 2020|      0|#endif
 2021|      0|                                }
 2022|  5.83k|                                else
 2023|  5.83k|                                {
 2024|  5.83k|                                    usedShortFlags.insert(flagString.shortFlag);
 2025|  5.83k|                                }
 2026|  5.83k|                            }
 2027|  5.83k|                            else
 2028|  5.83k|                            {
 2029|  5.83k|                                if(usedLongFlags.count(flagString.longFlag))
  ------------------
  |  Branch (2029:36): [True: 0, False: 5.83k]
  ------------------
 2030|      0|                                {
 2031|       |#ifdef ARGS_NOEXCEPT
 2032|       |                                    flag->SetUsageError();
 2033|       |#else
 2034|      0|                                    throw ParseError("duplicate long flag detected");
 2035|      0|#endif
 2036|      0|                                }
 2037|  5.83k|                                else
 2038|  5.83k|                                {
 2039|  5.83k|                                    usedLongFlags.insert(flagString.longFlag);
 2040|  5.83k|                                }
 2041|  5.83k|                            }
 2042|  11.6k|                        }
 2043|  5.83k|                    }
 2044|      0|                    else if(auto group = dynamic_cast<Group*>(child))
  ------------------
  |  Branch (2044:34): [True: 0, False: 0]
  ------------------
 2045|      0|                    {
 2046|       |                        // A command opens its own flag namespace and runs its
 2047|       |                        // own duplicate detection as a separate root, so a flag
 2048|       |                        // reused either side of a command boundary is not a
 2049|       |                        // genuine duplicate. Only descend into plain groups
 2050|       |                        // here; IsGroup() is false for a Command.
 2051|      0|                        if(group->IsGroup())
  ------------------
  |  Branch (2051:28): [True: 0, False: 0]
  ------------------
 2052|      0|                        {
 2053|      0|                            group->DetectDuplicateFlags(usedShortFlags, usedLongFlags);
 2054|      0|                        }
 2055|      0|                    }
 2056|  5.83k|                }
 2057|  2.91k|            }
_ZNK4args8FlagBase10GetMatcherEv:
 1388|  5.83k|            {
 1389|  5.83k|                return matcher;
 1390|  5.83k|            }
_ZNK4args7Matcher14GetFlagStringsEv:
  711|  5.83k|            {
  712|  5.83k|                std::vector<EitherFlag> flagStrings;
  713|  5.83k|                flagStrings.reserve(shortFlags.size() + longFlags.size());
  714|  5.83k|                for (const char flag: shortFlags)
  ------------------
  |  Branch (714:37): [True: 5.83k, False: 5.83k]
  ------------------
  715|  5.83k|                {
  716|  5.83k|                    flagStrings.emplace_back(flag);
  717|  5.83k|                }
  718|  5.83k|                for (const std::string &flag: longFlags)
  ------------------
  |  Branch (718:45): [True: 5.83k, False: 5.83k]
  ------------------
  719|  5.83k|                {
  720|  5.83k|                    flagStrings.emplace_back(flag);
  721|  5.83k|                }
  722|  5.83k|                return flagStrings;
  723|  5.83k|            }
_ZN4args10EitherFlagC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  573|  6.35k|        EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  498|    932|            ParseError(const std::string &problem) : Error(problem) {}
_ZN4args8FlagBaseD2Ev:
 1354|  2.91k|            virtual ~FlagBase() {}
_ZN4args4Flag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3808|  11.0k|            {
 3809|  11.0k|            }
_ZNK4args8FlagBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 1393|     66|            {
 1394|     66|                if (!Matched() && IsRequired())
  ------------------
  |  Branch (1394:21): [True: 33, False: 33]
  |  Branch (1394:35): [True: 0, False: 33]
  ------------------
 1395|      0|                {
 1396|      0|                        std::ostringstream problem;
 1397|      0|                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
 1398|       |#ifdef ARGS_NOEXCEPT
 1399|       |                        error = Error::Required;
 1400|       |                        errorMsg = problem.str();
 1401|       |#else
 1402|      0|                        throw RequiredError(problem.str());
 1403|      0|#endif
 1404|      0|                }
 1405|     66|            }
_ZNK4args4Base10IsRequiredEv:
 1033|     33|            {
 1034|     33|                return (GetOptions() & Options::Required) != Options::None;
 1035|     33|            }
_ZNK4args8FlagBase6IsFlagEv:
 1357|  2.91k|            {
 1358|  2.91k|                return true;
 1359|  2.91k|            }
_ZN4args8FlagBase5MatchERKNS_10EitherFlagE:
 1362|  33.4k|            {
 1363|  33.4k|                if (matcher.Match(flag))
  ------------------
  |  Branch (1363:21): [True: 11.0k, False: 22.3k]
  ------------------
 1364|  11.0k|                {
 1365|  11.0k|                    if ((GetOptions() & Options::Single) != Options::None && matched)
  ------------------
  |  Branch (1365:25): [True: 0, False: 11.0k]
  |  Branch (1365:78): [True: 0, False: 0]
  ------------------
 1366|      0|                    {
 1367|      0|                        std::ostringstream problem;
 1368|      0|                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
 1369|       |#ifdef ARGS_NOEXCEPT
 1370|       |                        error = Error::Extra;
 1371|       |                        errorMsg = problem.str();
 1372|       |#else
 1373|      0|                        throw ExtraError(problem.str());
 1374|      0|#endif
 1375|      0|                    }
 1376|  11.0k|                    matched = true;
 1377|  11.0k|                    return this;
 1378|  11.0k|                }
 1379|  22.3k|                return nullptr;
 1380|  33.4k|            }
_ZNK4args7Matcher5MatchERKNS_10EitherFlagE:
  704|  33.4k|            {
  705|  33.4k|                return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
  ------------------
  |  Branch (705:24): [True: 31.9k, False: 1.44k]
  ------------------
  706|  33.4k|            }
_ZNK4args7Matcher5MatchEc:
  690|  31.9k|            {
  691|  31.9k|                return shortFlags.find(flag) != shortFlags.end();
  692|  31.9k|            }
_ZNK4args7Matcher5MatchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  697|  1.44k|            {
  698|  1.44k|                return longFlags.find(flag) != longFlags.end();
  699|  1.44k|            }
_ZN4args5NargsC2Em:
  992|  11.0k|        Nargs(size_t num_) : min{num_}, max{num_}
  993|  11.0k|        {
  994|  11.0k|        }
_ZNK4args9NamedBase4NameEv:
 1234|     18|            {
 1235|     18|                return name;
 1236|     18|            }
_ZNK4args4Flag17NumberOfArgumentsEv:
 3803|  11.0k|            {
 3804|  11.0k|                return 0;
 3805|  11.0k|            }
_ZN4args8HelpFlag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3824|     18|            {
 3825|       |#ifdef ARGS_NOEXCEPT
 3826|       |                    error = Error::Help;
 3827|       |                    errorMsg = Name();
 3828|       |#else
 3829|     18|                    throw Help(Name());
 3830|     18|#endif
 3831|     18|            }
_ZN4args4HelpC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  543|     18|            Help(const std::string &flag) : Error(flag) {}
_ZN4args7MatcherD2Ev:
  685|  5.83k|            ~Matcher() {}
_ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEb:
 3789|  1.94k|            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false): Flag(group_, name_, help_, std::move(matcher_), extraError_ ? Options::Single : Options::None)
  ------------------
  |  Branch (3789:186): [True: 0, False: 1.94k]
  ------------------
 3790|  1.94k|            {
 3791|  1.94k|            }
_ZN4args14ArgumentParser9ParseArgsINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3681|    972|            {
 3682|       |                // Reset all Matched statuses and errors
 3683|    972|                Reset();
 3684|       |#ifdef ARGS_NOEXCEPT
 3685|       |                error = GetError();
 3686|       |                if (error != Error::None)
 3687|       |                {
 3688|       |                    return end;
 3689|       |                }
 3690|       |#endif
 3691|    972|                return Parse(begin, end);
 3692|    972|            }
_ZN4args14ArgumentParser5ParseINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3201|    972|            {
 3202|    972|                bool terminated = false;
 3203|    972|                std::vector<Command *> commands = GetCommands();
 3204|       |
 3205|       |                // Check all arg chunks
 3206|  2.10k|                for (auto it = begin; it != end; ++it)
  ------------------
  |  Branch (3206:39): [True: 1.38k, False: 725]
  ------------------
 3207|  1.38k|                {
 3208|  1.38k|                    if (Complete(it, end, terminated))
  ------------------
  |  Branch (3208:25): [True: 0, False: 1.38k]
  ------------------
 3209|      0|                    {
 3210|      0|                        return end;
 3211|      0|                    }
 3212|       |
 3213|  1.38k|                    const auto &chunk = *it;
 3214|       |
 3215|  1.38k|                    if (!terminated && chunk == terminator)
  ------------------
  |  Branch (3215:25): [True: 1.37k, False: 2]
  |  Branch (3215:40): [True: 3, False: 1.37k]
  ------------------
 3216|      3|                    {
 3217|      3|                        terminated = true;
 3218|  1.37k|                    } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
  ------------------
  |  Branch (3218:32): [True: 1.37k, False: 2]
  |  Branch (3218:47): [True: 518, False: 857]
  ------------------
 3219|    518|                    {
 3220|    518|                        if (!ParseLong(it, end))
  ------------------
  |  Branch (3220:29): [True: 0, False: 518]
  ------------------
 3221|      0|                        {
 3222|      0|                            return it;
 3223|      0|                        }
 3224|    859|                    } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
  ------------------
  |  Branch (3224:32): [True: 857, False: 2]
  |  Branch (3224:47): [True: 612, False: 245]
  ------------------
 3225|    612|                    {
 3226|    612|                        if (!ParseShort(it, end))
  ------------------
  |  Branch (3226:29): [True: 0, False: 612]
  ------------------
 3227|      0|                        {
 3228|      0|                            return it;
 3229|      0|                        }
 3230|    612|                    } else if (!terminated && !commands.empty())
  ------------------
  |  Branch (3230:32): [True: 245, False: 2]
  |  Branch (3230:47): [True: 0, False: 245]
  ------------------
 3231|      0|                    {
 3232|      0|                        auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
 3233|      0|                        if (itCommand == commands.end())
  ------------------
  |  Branch (3233:29): [True: 0, False: 0]
  ------------------
 3234|      0|                        {
 3235|      0|                            const std::string errorMessage("Unknown command: " + chunk);
 3236|      0|#ifndef ARGS_NOEXCEPT
 3237|      0|                            throw ParseError(errorMessage);
 3238|       |#else
 3239|       |                            error = Error::Parse;
 3240|       |                            errorMsg = errorMessage;
 3241|       |                            return it;
 3242|       |#endif
 3243|      0|                        }
 3244|       |
 3245|      0|                        SelectCommand(*itCommand);
 3246|       |
 3247|      0|                        if (const auto &coroutine = GetCoroutine())
  ------------------
  |  Branch (3247:41): [True: 0, False: 0]
  ------------------
 3248|      0|                        {
 3249|      0|                            ++it;
 3250|      0|                            RaiiSubparser coro(*this, std::vector<std::string>(it, end));
 3251|      0|                            coroutine(coro.Parser());
 3252|       |#ifdef ARGS_NOEXCEPT
 3253|       |                            error = GetError();
 3254|       |                            if (error != Error::None)
 3255|       |                            {
 3256|       |                                return end;
 3257|       |                            }
 3258|       |
 3259|       |                            if (!coro.Parser().IsParsed())
 3260|       |                            {
 3261|       |                                error = Error::Usage;
 3262|       |                                return end;
 3263|       |                            }
 3264|       |#else
 3265|      0|                            if (!coro.Parser().IsParsed())
  ------------------
  |  Branch (3265:33): [True: 0, False: 0]
  ------------------
 3266|      0|                            {
 3267|      0|                                throw UsageError("Subparser::Parse was not called");
 3268|      0|                            }
 3269|      0|#endif
 3270|       |
 3271|      0|                            break;
 3272|      0|                        }
 3273|       |
 3274|      0|                        commands = GetCommands();
 3275|      0|                    } else
 3276|    247|                    {
 3277|    247|                        auto pos = GetNextPositional();
 3278|    247|                        if (pos)
  ------------------
  |  Branch (3278:29): [True: 0, False: 247]
  ------------------
 3279|      0|                        {
 3280|      0|                            pos->ParseValue(chunk);
 3281|       |#ifdef ARGS_NOEXCEPT
 3282|       |                            if (pos->GetError() != Error::None)
 3283|       |                            {
 3284|       |                                return it;
 3285|       |                            }
 3286|       |#endif
 3287|       |
 3288|      0|                            if (pos->KickOut())
  ------------------
  |  Branch (3288:33): [True: 0, False: 0]
  ------------------
 3289|      0|                            {
 3290|      0|                                return ++it;
 3291|      0|                            }
 3292|      0|                        } else
 3293|    247|                        {
 3294|    247|                            const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
 3295|    247|#ifndef ARGS_NOEXCEPT
 3296|    247|                            throw ParseError(errorMessage);
 3297|       |#else
 3298|       |                            error = Error::Parse;
 3299|       |                            errorMsg = errorMessage;
 3300|       |                            return it;
 3301|       |#endif
 3302|    247|                        }
 3303|    247|                    }
 3304|       |
 3305|  1.13k|                    if (!readCompletion && completion != nullptr && completion->Matched())
  ------------------
  |  Branch (3305:25): [True: 430, False: 703]
  |  Branch (3305:44): [True: 0, False: 430]
  |  Branch (3305:69): [True: 0, False: 0]
  ------------------
 3306|      0|                    {
 3307|       |#ifdef ARGS_NOEXCEPT
 3308|       |                        if (completion->GetError() != Error::None)
 3309|       |                        {
 3310|       |                            error = completion->GetError();
 3311|       |                            if (errorMsg.empty())
 3312|       |                            {
 3313|       |                                errorMsg = completion->GetErrorMsg();
 3314|       |                            }
 3315|       |                            return it;
 3316|       |                        }
 3317|       |
 3318|       |                        error = Error::Completion;
 3319|       |#endif
 3320|      0|                        readCompletion = true;
 3321|      0|                        ++it;
 3322|      0|                        const auto argsLeft = static_cast<size_t>(std::distance(it, end));
 3323|      0|                        if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
  ------------------
  |  Branch (3323:29): [True: 0, False: 0]
  |  Branch (3323:55): [True: 0, False: 0]
  |  Branch (3323:72): [True: 0, False: 0]
  ------------------
 3324|      0|                        {
 3325|      0|#ifndef ARGS_NOEXCEPT
 3326|      0|                            throw Completion("");
 3327|       |#else
 3328|       |                            return end;
 3329|       |#endif
 3330|      0|                        }
 3331|       |
 3332|      0|                        ++it;
 3333|      0|                        std::vector<std::string> curArgs;
 3334|      0|                        curArgs.reserve(completion->cword);
 3335|      0|                        auto curIt = it;
 3336|      0|                        for (size_t idx = 0; idx < completion->cword && curIt != end; ++idx, ++curIt)
  ------------------
  |  Branch (3336:46): [True: 0, False: 0]
  |  Branch (3336:73): [True: 0, False: 0]
  ------------------
 3337|      0|                        {
 3338|      0|                            curArgs.push_back(*curIt);
 3339|      0|                        }
 3340|       |
 3341|      0|                        if (completion->syntax == "bash")
  ------------------
  |  Branch (3341:29): [True: 0, False: 0]
  ------------------
 3342|      0|                        {
 3343|       |                            // bash tokenizes --flag=value as --flag=value
 3344|       |                            // Security fix: Use size_t arithmetic throughout to avoid conversion issues
 3345|      0|                            for (size_t idx = 0; idx < curArgs.size(); )
  ------------------
  |  Branch (3345:50): [True: 0, False: 0]
  ------------------
 3346|      0|                            {
 3347|      0|                                if (idx > 0 && curArgs[idx] == "=")
  ------------------
  |  Branch (3347:37): [True: 0, False: 0]
  |  Branch (3347:48): [True: 0, False: 0]
  ------------------
 3348|      0|                                {
 3349|      0|                                    size_t prev_idx = idx - 1;  // Safe since we checked idx > 0
 3350|      0|                                    curArgs[prev_idx] += "=";
 3351|      0|                                    size_t next_idx = 0;
 3352|      0|                                    if (SafeAdd<size_t>(idx, static_cast<size_t>(1), next_idx) && next_idx < curArgs.size())
  ------------------
  |  Branch (3352:41): [True: 0, False: 0]
  |  Branch (3352:99): [True: 0, False: 0]
  ------------------
 3353|      0|                                    {
 3354|      0|                                        curArgs[prev_idx] += curArgs[next_idx];
 3355|       |                                        // Erase the '=' token and the following value token.
 3356|      0|                                        size_t erase_end = 0;
 3357|      0|                                        if (SafeAdd<size_t>(next_idx, static_cast<size_t>(1), erase_end))
  ------------------
  |  Branch (3357:45): [True: 0, False: 0]
  ------------------
 3358|      0|                                        {
 3359|      0|                                            typedef std::vector<std::string>::difference_type diff_t;
 3360|      0|                                            curArgs.erase(curArgs.begin() + static_cast<diff_t>(idx),
 3361|      0|                                                         curArgs.begin() + static_cast<diff_t>(erase_end));
 3362|      0|                                        }
 3363|      0|                                    } else
 3364|      0|                                    {
 3365|       |                                        // Safe erase of single '=' token at the end
 3366|      0|                                        typedef std::vector<std::string>::difference_type diff_t;
 3367|      0|                                        curArgs.erase(curArgs.begin() + static_cast<diff_t>(idx));
 3368|      0|                                    }
 3369|       |                                    // Do not increment idx - next element slides into current position
 3370|      0|                                } else
 3371|      0|                                {
 3372|      0|                                    ++idx;
 3373|      0|                                }
 3374|      0|                            }
 3375|       |
 3376|      0|                        }
 3377|      0|#ifndef ARGS_NOEXCEPT
 3378|      0|                        try
 3379|      0|                        {
 3380|      0|                            Parse(curArgs.begin(), curArgs.end());
 3381|      0|                            throw Completion("");
 3382|      0|                        }
 3383|      0|                        catch (Completion &)
 3384|      0|                        {
 3385|      0|                            throw;
 3386|      0|                        }
 3387|      0|                        catch (args::Error&)
 3388|      0|                        {
 3389|      0|                            throw Completion("");
 3390|      0|                        }
 3391|       |#else
 3392|       |                        // Discard the nested Parse's return value: it points
 3393|       |                        // into the local curArgs vector, which is destroyed
 3394|       |                        // when this function returns, leaving the caller with
 3395|       |                        // a dangling iterator that would be compared against
 3396|       |                        // the outer `end` in ParseCLI. Return the outer
 3397|       |                        // `end` instead so the iterator stays in the caller's
 3398|       |                        // container.
 3399|       |                        Parse(curArgs.begin(), curArgs.end());
 3400|       |                        error = Error::Completion;
 3401|       |                        errorMsg.clear();
 3402|       |                        return end;
 3403|       |#endif
 3404|      0|                    }
 3405|  1.13k|                }
 3406|       |
 3407|    725|                Validate(shortprefix, longprefix);
 3408|    725|                return end;
 3409|    972|            }
_ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbT_SC_b:
 3073|  1.38k|            {
 3074|  1.38k|                auto nextIt = it;
 3075|  1.38k|                if (!readCompletion || (++nextIt != end))
  ------------------
  |  Branch (3075:21): [True: 1.38k, False: 0]
  |  Branch (3075:40): [True: 0, False: 0]
  ------------------
 3076|  1.38k|                {
 3077|  1.38k|                    return false;
 3078|  1.38k|                }
 3079|       |
 3080|      0|                const auto &chunk = *it;
 3081|      0|                auto pos = GetNextPositional();
 3082|      0|                std::vector<Command *> commands = GetCommands();
 3083|      0|                const auto optionType = ParseOption(chunk, true);
 3084|       |
 3085|       |                // Once the terminator has been seen the parser treats every
 3086|       |                // following chunk as positional, so only positional choices are
 3087|       |                // valid completions here. Suggesting flags or commands past the
 3088|       |                // terminator offers candidates the parser would then reject.
 3089|      0|                if (!terminated && !commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
  ------------------
  |  Branch (3089:21): [True: 0, False: 0]
  |  Branch (3089:36): [True: 0, False: 0]
  |  Branch (3089:58): [True: 0, False: 0]
  |  Branch (3089:75): [True: 0, False: 0]
  ------------------
 3090|      0|                {
 3091|      0|                    for (auto &cmd : commands)
  ------------------
  |  Branch (3091:36): [True: 0, False: 0]
  ------------------
 3092|      0|                    {
 3093|      0|                        if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3093:29): [True: 0, False: 0]
  ------------------
 3094|      0|                        {
 3095|      0|                            AddCompletionReply(chunk, cmd->Name());
 3096|      0|                        }
 3097|      0|                    }
 3098|      0|                } else
 3099|      0|                {
 3100|      0|                    bool hasPositionalCompletion = true;
 3101|       |
 3102|      0|                    if (!terminated && !commands.empty())
  ------------------
  |  Branch (3102:25): [True: 0, False: 0]
  |  Branch (3102:40): [True: 0, False: 0]
  ------------------
 3103|      0|                    {
 3104|      0|                        for (auto &cmd : commands)
  ------------------
  |  Branch (3104:40): [True: 0, False: 0]
  ------------------
 3105|      0|                        {
 3106|      0|                            if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3106:33): [True: 0, False: 0]
  ------------------
 3107|      0|                            {
 3108|      0|                                AddCompletionReply(chunk, cmd->Name());
 3109|      0|                            }
 3110|      0|                        }
 3111|      0|                    } else if (pos)
  ------------------
  |  Branch (3111:32): [True: 0, False: 0]
  ------------------
 3112|      0|                    {
 3113|      0|                        if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3113:29): [True: 0, False: 0]
  ------------------
 3114|      0|                        {
 3115|      0|                            auto choices = pos->HelpChoices(helpParams);
 3116|      0|                            hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
  ------------------
  |  Branch (3116:55): [True: 0, False: 0]
  |  Branch (3116:75): [True: 0, False: 0]
  ------------------
 3117|      0|                            for (auto &choice : choices)
  ------------------
  |  Branch (3117:47): [True: 0, False: 0]
  ------------------
 3118|      0|                            {
 3119|      0|                                AddCompletionReply(chunk, choice);
 3120|      0|                            }
 3121|      0|                        }
 3122|      0|                    }
 3123|       |
 3124|      0|                    if (!terminated && hasPositionalCompletion)
  ------------------
  |  Branch (3124:25): [True: 0, False: 0]
  |  Branch (3124:40): [True: 0, False: 0]
  ------------------
 3125|      0|                    {
 3126|      0|                        auto flags = GetAllFlags();
 3127|      0|                        for (auto flag : flags)
  ------------------
  |  Branch (3127:40): [True: 0, False: 0]
  ------------------
 3128|      0|                        {
 3129|      0|                            if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
  ------------------
  |  Branch (3129:33): [True: 0, False: 0]
  ------------------
 3130|      0|                            {
 3131|      0|                                continue;
 3132|      0|                            }
 3133|       |
 3134|      0|                            auto &matcher = flag->GetMatcher();
 3135|      0|                            if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
  ------------------
  |  Branch (3135:33): [True: 0, False: 0]
  ------------------
 3136|      0|                            {
 3137|      0|                                for (auto &flagName : matcher.GetFlagStrings())
  ------------------
  |  Branch (3137:53): [True: 0, False: 0]
  ------------------
 3138|      0|                                {
 3139|      0|                                    if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
  ------------------
  |  Branch (3139:41): [True: 0, False: 0]
  ------------------
 3140|      0|                                    {
 3141|      0|                                        break;
 3142|      0|                                    }
 3143|      0|                                }
 3144|      0|                            }
 3145|      0|                        }
 3146|       |
 3147|      0|                        if (optionType == OptionType::LongFlag && allowJoinedLongValue)
  ------------------
  |  Branch (3147:29): [True: 0, False: 0]
  |  Branch (3147:67): [True: 0, False: 0]
  ------------------
 3148|      0|                        {
 3149|      0|                            const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
  ------------------
  |  Branch (3149:52): [True: 0, False: 0]
  ------------------
 3150|       |                            // Only attempt joined-value completion when the
 3151|       |                            // separator lies at or past the long prefix, so
 3152|       |                            // there is a (possibly empty) flag name between
 3153|       |                            // them. With a custom longseparator that overlaps
 3154|       |                            // the prefix (e.g. LongSeparator("-") under the
 3155|       |                            // default "--" prefix), an attacker-controlled
 3156|       |                            // completion word like "--x" puts the separator
 3157|       |                            // inside the prefix, making `arg` shorter than
 3158|       |                            // longprefix. arg.substr(longprefix.size()) would
 3159|       |                            // then throw std::out_of_range, which escapes the
 3160|       |                            // parser as a non-args exception (bypassing the
 3161|       |                            // documented catch(args::Error) idiom) and is
 3162|       |                            // thrown even under ARGS_NOEXCEPT.
 3163|      0|                            if (separator != chunk.npos && separator >= longprefix.size())
  ------------------
  |  Branch (3163:33): [True: 0, False: 0]
  |  Branch (3163:60): [True: 0, False: 0]
  ------------------
 3164|      0|                            {
 3165|      0|                                std::string arg(chunk, 0, separator);
 3166|      0|                                if (auto flag = this->Match(arg.substr(longprefix.size())))
  ------------------
  |  Branch (3166:42): [True: 0, False: 0]
  ------------------
 3167|      0|                                {
 3168|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (3168:55): [True: 0, False: 0]
  ------------------
 3169|      0|                                    {
 3170|      0|                                        AddCompletionReply(chunk, arg + longseparator + choice);
 3171|      0|                                    }
 3172|      0|                                }
 3173|      0|                            }
 3174|      0|                        } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
  ------------------
  |  Branch (3174:36): [True: 0, False: 0]
  |  Branch (3174:75): [True: 0, False: 0]
  ------------------
 3175|      0|                        {
 3176|      0|                            if (chunk.size() > shortprefix.size() + 1)
  ------------------
  |  Branch (3176:33): [True: 0, False: 0]
  ------------------
 3177|      0|                            {
 3178|      0|                                auto arg = chunk.at(shortprefix.size());
 3179|       |                                //TODO: support -abcVALUE where a and b take no value
 3180|      0|                                if (auto flag = this->Match(arg))
  ------------------
  |  Branch (3180:42): [True: 0, False: 0]
  ------------------
 3181|      0|                                {
 3182|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (3182:55): [True: 0, False: 0]
  ------------------
 3183|      0|                                    {
 3184|      0|                                        AddCompletionReply(chunk, shortprefix + arg + choice);
 3185|      0|                                    }
 3186|      0|                                }
 3187|      0|                            }
 3188|      0|                        }
 3189|      0|                    }
 3190|      0|                }
 3191|       |
 3192|      0|#ifndef ARGS_NOEXCEPT
 3193|      0|                throw Completion(completion->Get());
 3194|       |#else
 3195|       |                return true;
 3196|       |#endif
 3197|  1.38k|            }
_ZN4args14ArgumentParser11ParseOptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 2751|  2.23k|            {
 2752|  2.23k|                const bool matchesLong = s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length());
  ------------------
  |  Branch (2752:42): [True: 518, False: 1.71k]
  |  Branch (2752:70): [True: 0, False: 518]
  |  Branch (2752:84): [True: 518, False: 0]
  ------------------
 2753|  2.23k|                const bool matchesShort = s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length());
  ------------------
  |  Branch (2753:43): [True: 1.75k, False: 482]
  |  Branch (2753:72): [True: 0, False: 1.75k]
  |  Branch (2753:86): [True: 1.74k, False: 8]
  ------------------
 2754|       |
 2755|       |                // A chunk can start with both prefixes when one is a prefix of
 2756|       |                // the other, or when the long prefix is empty (every string
 2757|       |                // starts with it). Resolve to the longer, more specific prefix:
 2758|       |                // this keeps the default "--"/"-" preference for long flags
 2759|       |                // while letting a short flag be recognised under an empty long
 2760|       |                // prefix instead of being swallowed as a nameless long flag.
 2761|  2.23k|                if (matchesLong && matchesShort)
  ------------------
  |  Branch (2761:21): [True: 518, False: 1.71k]
  |  Branch (2761:36): [True: 518, False: 0]
  ------------------
 2762|    518|                {
 2763|    518|                    return longprefix.length() >= shortprefix.length() ? OptionType::LongFlag : OptionType::ShortFlag;
  ------------------
  |  Branch (2763:28): [True: 518, False: 0]
  ------------------
 2764|    518|                }
 2765|       |
 2766|  1.71k|                if (matchesLong)
  ------------------
  |  Branch (2766:21): [True: 0, False: 1.71k]
  ------------------
 2767|      0|                {
 2768|      0|                    return OptionType::LongFlag;
 2769|      0|                }
 2770|       |
 2771|  1.71k|                if (matchesShort)
  ------------------
  |  Branch (2771:21): [True: 1.22k, False: 490]
  ------------------
 2772|  1.22k|                {
 2773|  1.22k|                    return OptionType::ShortFlag;
 2774|  1.22k|                }
 2775|       |
 2776|    490|                return OptionType::Positional;
 2777|  1.71k|            }
_ZN4args14ArgumentParser9ParseLongINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2901|    518|            {
 2902|    518|                const auto &chunk = *it;
 2903|    518|                const auto argchunk = chunk.substr(longprefix.size());
 2904|       |                // Try to separate it, in case of a separator:
 2905|    518|                const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
  ------------------
  |  Branch (2905:40): [True: 0, False: 518]
  ------------------
 2906|       |                // If the separator is in the argument, separate it.
 2907|    518|                const auto arg = (separator != argchunk.npos ?
  ------------------
  |  Branch (2907:35): [True: 238, False: 280]
  ------------------
 2908|    238|                    std::string(argchunk, 0, separator)
 2909|    518|                    : argchunk);
 2910|    518|                const auto joined = (separator != argchunk.npos ?
  ------------------
  |  Branch (2910:38): [True: 238, False: 280]
  ------------------
 2911|    238|                    argchunk.substr(separator + longseparator.size())
 2912|    518|                    : std::string());
 2913|       |
 2914|    518|                if (auto flag = Match(arg))
  ------------------
  |  Branch (2914:26): [True: 98, False: 420]
  ------------------
 2915|     98|                {
 2916|       |#ifdef ARGS_NOEXCEPT
 2917|       |                    // Match() may set the flag's error (e.g. Error::Extra when
 2918|       |                    // Options::Single is violated). In non-noexcept mode that
 2919|       |                    // path throws and parsing stops before the value is read;
 2920|       |                    // in noexcept mode we must mirror that and skip the value
 2921|       |                    // parsing so the previously-stored value is preserved.
 2922|       |                    if (flag->GetError() != Error::None)
 2923|       |                    {
 2924|       |                        return false;
 2925|       |                    }
 2926|       |#endif
 2927|     98|                    std::vector<std::string> values;
 2928|     98|                    const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
 2929|     98|                                                                     separator != argchunk.npos, joined, false, values);
 2930|     98|                    if (!errorMessage.empty())
  ------------------
  |  Branch (2930:25): [True: 19, False: 79]
  ------------------
 2931|     19|                    {
 2932|     19|#ifndef ARGS_NOEXCEPT
 2933|     19|                        throw ParseError(errorMessage);
 2934|       |#else
 2935|       |                        error = Error::Parse;
 2936|       |                        errorMsg = errorMessage;
 2937|       |                        return false;
 2938|       |#endif
 2939|     19|                    }
 2940|       |
 2941|     79|                    if (!readCompletion)
  ------------------
  |  Branch (2941:25): [True: 79, False: 0]
  ------------------
 2942|     79|                    {
 2943|     79|                        flag->ParseValue(values);
 2944|       |#ifdef ARGS_NOEXCEPT
 2945|       |                        // Non-noexcept ParseValue paths throw on Help, reader
 2946|       |                        // failure, or Map miss, which halts parsing. Mirror
 2947|       |                        // that here so a later parser-level error (e.g. an
 2948|       |                        // unknown flag) cannot shadow the flag's error in
 2949|       |                        // ArgumentParser::GetError().
 2950|       |                        if (flag->GetError() != Error::None)
 2951|       |                        {
 2952|       |                            return false;
 2953|       |                        }
 2954|       |#endif
 2955|     79|                    }
 2956|       |
 2957|     79|                    if (flag->KickOut())
  ------------------
  |  Branch (2957:25): [True: 0, False: 79]
  ------------------
 2958|      0|                    {
 2959|      0|                        ++it;
 2960|      0|                        return false;
 2961|      0|                    }
 2962|     79|                } else
 2963|    420|                {
 2964|    420|                    const std::string errorMessage("Flag could not be matched: " + arg);
 2965|    420|#ifndef ARGS_NOEXCEPT
 2966|    420|                    throw ParseError(errorMessage);
 2967|       |#else
 2968|       |                    error = Error::Parse;
 2969|       |                    errorMsg = errorMessage;
 2970|       |                    return false;
 2971|       |#endif
 2972|    420|                }
 2973|       |
 2974|     79|                return true;
 2975|    518|            }
_ZN4args14ArgumentParser15ParseArgsValuesINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_RNS_8FlagBaseERKS9_RT_SG_bbbSF_bRNS2_6vectorIS9_NS7_IS9_EEEE:
 2815|  11.0k|            {
 2816|  11.0k|                values.clear();
 2817|       |
 2818|  11.0k|                Nargs nargs = flag.NumberOfArguments();
 2819|       |
 2820|  11.0k|                if (hasJoined && !allowJoined && (nargs.min != 0 || !canDiscardJoined))
  ------------------
  |  Branch (2820:21): [True: 10.6k, False: 429]
  |  Branch (2820:34): [True: 0, False: 10.6k]
  |  Branch (2820:51): [True: 0, False: 0]
  |  Branch (2820:69): [True: 0, False: 0]
  ------------------
 2821|      0|                {
 2822|      0|                    return "Flag '" + arg + "' was passed a joined argument, but these are disallowed";
 2823|      0|                }
 2824|       |
 2825|  11.0k|                if (hasJoined)
  ------------------
  |  Branch (2825:21): [True: 10.6k, False: 429]
  ------------------
 2826|  10.6k|                {
 2827|  10.6k|                    if (!canDiscardJoined || (allowJoined && nargs.max != 0))
  ------------------
  |  Branch (2827:25): [True: 19, False: 10.6k]
  |  Branch (2827:47): [True: 10.6k, False: 0]
  |  Branch (2827:62): [True: 0, False: 10.6k]
  ------------------
 2828|     19|                    {
 2829|     19|                        values.push_back(joinedArg);
 2830|     19|                    }
 2831|  10.6k|                } else if (!allowSeparate)
  ------------------
  |  Branch (2831:28): [True: 0, False: 429]
  ------------------
 2832|      0|                {
 2833|      0|                    if (nargs.min != 0)
  ------------------
  |  Branch (2833:25): [True: 0, False: 0]
  ------------------
 2834|      0|                    {
 2835|      0|                        return "Flag '" + arg + "' was passed a separate argument, but these are disallowed";
 2836|      0|                    }
 2837|      0|                }
 2838|       |
 2839|       |                // Only gather separate values when they are allowed. A joined
 2840|       |                // value that was discarded rather than taken (short chunks such
 2841|       |                // as -nf when joined short values are off) means this flag isn't
 2842|       |                // taking an argument here, so the rest of the chunk is flags.
 2843|  11.0k|                if (allowSeparate && (!hasJoined || !values.empty()))
  ------------------
  |  Branch (2843:21): [True: 11.0k, False: 0]
  |  Branch (2843:39): [True: 429, False: 10.6k]
  |  Branch (2843:53): [True: 19, False: 10.6k]
  ------------------
 2844|    448|                {
 2845|    448|                    auto valueIt = it;
 2846|    448|                    ++valueIt;
 2847|       |
 2848|    448|                    while (valueIt != end &&
  ------------------
  |  Branch (2848:28): [True: 417, False: 31]
  ------------------
 2849|    417|                           *valueIt != terminator &&
  ------------------
  |  Branch (2849:28): [True: 416, False: 1]
  ------------------
 2850|    416|                           values.size() < nargs.max &&
  ------------------
  |  Branch (2850:28): [True: 0, False: 416]
  ------------------
 2851|      0|                           (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional))
  ------------------
  |  Branch (2851:29): [True: 0, False: 0]
  |  Branch (2851:58): [True: 0, False: 0]
  ------------------
 2852|      0|                    {
 2853|      0|                        if (Complete(flag, valueIt, end))
  ------------------
  |  Branch (2853:29): [True: 0, False: 0]
  ------------------
 2854|      0|                        {
 2855|       |                            // Park `it` on the completion position rather than
 2856|       |                            // `end`. In ARGS_NOEXCEPT mode Complete returns
 2857|       |                            // true (no throw), so the caller's for-loop will
 2858|       |                            // run its ++it after we return; advancing an
 2859|       |                            // already-end iterator is undefined behavior and
 2860|       |                            // causes a subsequent out-of-bounds read of the
 2861|       |                            // arg vector. Since Complete only fires when
 2862|       |                            // ++nextIt == end, valueIt is the last element,
 2863|       |                            // and ++(it=valueIt) safely lands on end.
 2864|      0|                            it = valueIt;
 2865|      0|                            return "";
 2866|      0|                        }
 2867|       |
 2868|      0|                        values.push_back(*valueIt);
 2869|      0|                        ++it;
 2870|      0|                        ++valueIt;
 2871|      0|                    }
 2872|    448|                }
 2873|       |
 2874|  11.0k|                if (values.size() > nargs.max)
  ------------------
  |  Branch (2874:21): [True: 19, False: 11.0k]
  ------------------
 2875|     19|                {
 2876|     19|                    return "Passed an argument into a non-argument flag: " + arg;
 2877|  11.0k|                } else if (values.size() < nargs.min)
  ------------------
  |  Branch (2877:28): [True: 0, False: 11.0k]
  ------------------
 2878|      0|                {
 2879|      0|                    if (nargs.min == 1 && nargs.max == 1)
  ------------------
  |  Branch (2879:25): [True: 0, False: 0]
  |  Branch (2879:43): [True: 0, False: 0]
  ------------------
 2880|      0|                    {
 2881|      0|                        return "Flag '" + arg + "' requires an argument but received none";
 2882|      0|                    } else if (nargs.min == 1)
  ------------------
  |  Branch (2882:32): [True: 0, False: 0]
  ------------------
 2883|      0|                    {
 2884|      0|                        return "Flag '" + arg + "' requires at least one argument but received none";
 2885|      0|                    } else if (nargs.min != nargs.max)
  ------------------
  |  Branch (2885:32): [True: 0, False: 0]
  ------------------
 2886|      0|                    {
 2887|      0|                        return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
 2888|      0|                               " arguments but received " + std::to_string(values.size());
 2889|      0|                    } else
 2890|      0|                    {
 2891|      0|                        return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
 2892|      0|                               " arguments but received " + std::to_string(values.size());
 2893|      0|                    }
 2894|      0|                }
 2895|       |
 2896|  11.0k|                return {};
 2897|  11.0k|            }
_ZN4args14ArgumentParser10ParseShortINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2979|    612|            {
 2980|    612|                const auto &chunk = *it;
 2981|    612|                const auto argchunk = chunk.substr(shortprefix.size());
 2982|  11.5k|                for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
  ------------------
  |  Branch (2982:57): [True: 11.2k, False: 366]
  ------------------
 2983|  11.2k|                {
 2984|  11.2k|                    const auto arg = *argit;
 2985|       |
 2986|  11.2k|                    if (auto flag = Match(arg))
  ------------------
  |  Branch (2986:30): [True: 10.9k, False: 246]
  ------------------
 2987|  10.9k|                    {
 2988|       |#ifdef ARGS_NOEXCEPT
 2989|       |                        // See ParseLong: if Match recorded an error
 2990|       |                        // (e.g. Options::Single violation), bail before the
 2991|       |                        // value is parsed so the prior value is preserved.
 2992|       |                        if (flag->GetError() != Error::None)
 2993|       |                        {
 2994|       |                            return false;
 2995|       |                        }
 2996|       |#endif
 2997|  10.9k|                        const std::string value(argit + 1, std::end(argchunk));
 2998|  10.9k|                        std::vector<std::string> values;
 2999|  10.9k|                        const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
 3000|  10.9k|                                                                         allowSeparateShortValue, allowJoinedShortValue,
 3001|  10.9k|                                                                         !value.empty(), value, !value.empty(), values);
 3002|       |
 3003|  10.9k|                        if (!errorMessage.empty())
  ------------------
  |  Branch (3003:29): [True: 0, False: 10.9k]
  ------------------
 3004|      0|                        {
 3005|      0|#ifndef ARGS_NOEXCEPT
 3006|      0|                            throw ParseError(errorMessage);
 3007|       |#else
 3008|       |                            error = Error::Parse;
 3009|       |                            errorMsg = errorMessage;
 3010|       |                            return false;
 3011|       |#endif
 3012|      0|                        }
 3013|       |
 3014|  10.9k|                        if (!readCompletion)
  ------------------
  |  Branch (3014:29): [True: 10.9k, False: 0]
  ------------------
 3015|  10.9k|                        {
 3016|  10.9k|                            flag->ParseValue(values);
 3017|       |#ifdef ARGS_NOEXCEPT
 3018|       |                            // See ParseLong: ensure a flag-level error from
 3019|       |                            // ParseValue (Help, Parse, Map) halts parsing so
 3020|       |                            // it cannot be shadowed by a later parser error.
 3021|       |                            if (flag->GetError() != Error::None)
 3022|       |                            {
 3023|       |                                return false;
 3024|       |                            }
 3025|       |#endif
 3026|  10.9k|                        }
 3027|       |
 3028|  10.9k|                        if (flag->KickOut())
  ------------------
  |  Branch (3028:29): [True: 0, False: 10.9k]
  ------------------
 3029|      0|                        {
 3030|      0|                            ++it;
 3031|      0|                            return false;
 3032|      0|                        }
 3033|       |
 3034|  10.9k|                        if (!values.empty())
  ------------------
  |  Branch (3034:29): [True: 0, False: 10.9k]
  ------------------
 3035|      0|                        {
 3036|      0|                            break;
 3037|      0|                        }
 3038|  10.9k|                    } else
 3039|    246|                    {
 3040|    246|                        const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
 3041|    246|#ifndef ARGS_NOEXCEPT
 3042|    246|                        throw ParseError(errorMessage);
 3043|       |#else
 3044|       |                        error = Error::Parse;
 3045|       |                        errorMsg = errorMessage;
 3046|       |                        return false;
 3047|       |#endif
 3048|    246|                    }
 3049|  11.2k|                }
 3050|       |
 3051|    366|                return true;
 3052|    612|            }
_ZNK4args4Base7KickOutEv:
 1124|  11.0k|            {
 1125|  11.0k|                return (options & Options::KickOut) != Options::None;
 1126|  11.0k|            }

LLVMFuzzerTestOneInput:
    7|    972|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    8|    972|    auto fdp = FuzzedDataProvider(data, size);
    9|       |
   10|    972|    auto parser = args::ArgumentParser("parse_args_fuzzer");
   11|       |
   12|    972|    auto help = args::HelpFlag(parser, "help", "Displays this help menu", {'h', "help"});
   13|    972|    auto test = args::Flag(parser, "test", "Test flag", {'t', "test"});
   14|    972|    auto param = args::Flag(parser, "param", "Param flag", {'p', "param"});
   15|       |
   16|    972|    auto count = fdp.ConsumeIntegralInRange(1, 10);
   17|    972|    auto arguments = std::vector<std::string>();
   18|    972|    arguments.reserve(count);
   19|  5.51k|    for (int i = 0; i < count; ++i) {
  ------------------
  |  Branch (19:21): [True: 4.53k, False: 972]
  ------------------
   20|  4.53k|        arguments.emplace_back(fdp.ConsumeRandomLengthString());
   21|  4.53k|    }
   22|       |
   23|    972|    try {
   24|    972|        parser.ParseArgs(arguments.begin(), arguments.end());
   25|    972|    } catch (...) {
   26|    950|    }
   27|       |
   28|    972|    return 0;
   29|    972|}