_ZN4args14ArgumentParserC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 3399|    948|            {
 3400|    948|                Description(description_);
 3401|    948|                Epilog(epilog_);
 3402|    948|                LongPrefix("--");
 3403|    948|                ShortPrefix("-");
 3404|    948|                LongSeparator("=");
 3405|    948|                Terminator("--");
 3406|    948|                SetArgumentSeparations(true, true, true, true);
 3407|    948|                matched = true;
 3408|    948|            }
_ZN4args7CommandC2Ev:
 2215|    948|            Command() = default;
_ZN4args5GroupC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_8functionIFbRKS0_EEENS_7OptionsE:
 1699|    948|            Group(const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_)
 1700|    948|            {
 1701|    948|                parent = nullptr;
 1702|    948|            }
_ZN4args4BaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7OptionsE:
 1024|  3.79k|            Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
_ZNK4args4Base7MatchedEv:
 1038|  24.2k|            {
 1039|  24.2k|                return matched;
 1040|  24.2k|            }
_ZN4args4Base11GetCommandsEv:
 1060|  2.84k|            {
 1061|  2.84k|                return {};
 1062|  2.84k|            }
_ZNK4args4Base7IsGroupEv:
 1065|     78|            {
 1066|     78|                return false;
 1067|     78|            }
_ZN4args4Base17GetNextPositionalEv:
 1080|    708|            {
 1081|    708|                return nullptr;
 1082|    708|            }
_ZNK4args4Base10HasCommandEv:
 1100|     78|            {
 1101|     78|                return false;
 1102|     78|            }
_ZN4args4Base5ResetEv:
 1129|  3.79k|            {
 1130|  3.79k|                matched = false;
 1131|       |#ifdef ARGS_NOEXCEPT
 1132|       |                error = Error::None;
 1133|       |                errorMsg.clear();
 1134|       |#endif
 1135|  3.79k|            }
_ZN4args4BaseD2Ev:
 1025|  3.79k|            virtual ~Base() {}
_ZN4args5GroupD2Ev:
 1709|    948|            virtual ~Group() {}
_ZNK4args5Group8ChildrenEv:
 1742|  28.0k|            {
 1743|  28.0k|                return children;
 1744|  28.0k|            }
_ZN4argsanENS_7OptionsES0_:
  809|  44.6k|    {
  810|  44.6k|        return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
  811|  44.6k|    }
_ZNK4args4Base10GetOptionsEv:
 1028|  22.3k|            {
 1029|  22.3k|                return options;
 1030|  22.3k|            }
_ZN4args5Group11GetCommandsEv:
 1935|    948|            {
 1936|    948|                std::vector<Command*> res;
 1937|    948|                for (const auto &child : Children())
  ------------------
  |  Branch (1937:40): [True: 2.84k, False: 948]
  ------------------
 1938|  2.84k|                {
 1939|  2.84k|                    auto subparsers = child->GetCommands();
 1940|  2.84k|                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
 1941|  2.84k|                }
 1942|    948|                return res;
 1943|    948|            }
_ZN4args5Group5MatchERKNS_10EitherFlagE:
 1752|  22.9k|            {
 1753|  22.9k|                for (Base *child: Children())
  ------------------
  |  Branch (1753:33): [True: 66.8k, False: 653]
  ------------------
 1754|  66.8k|                {
 1755|  66.8k|                    if (FlagBase *match = child->Match(flag))
  ------------------
  |  Branch (1755:35): [True: 22.3k, False: 44.5k]
  ------------------
 1756|  22.3k|                    {
 1757|  22.3k|                        return match;
 1758|  22.3k|                    }
 1759|  66.8k|                }
 1760|    653|                return nullptr;
 1761|  22.9k|            }
_ZN4args5Group17GetNextPositionalEv:
 1787|    236|            {
 1788|    236|                for (Base *child: Children())
  ------------------
  |  Branch (1788:33): [True: 708, False: 236]
  ------------------
 1789|    708|                {
 1790|    708|                    if (auto next = child->GetNextPositional())
  ------------------
  |  Branch (1790:30): [True: 0, False: 708]
  ------------------
 1791|      0|                    {
 1792|      0|                        return next;
 1793|      0|                    }
 1794|    708|                }
 1795|    236|                return nullptr;
 1796|    236|            }
_ZNK4args5Group10HasCommandEv:
 1821|     26|            {
 1822|     26|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
 1823|     26|            }
_ZZNK4args5Group10HasCommandEvENKUlPNS_4BaseEE_clES2_:
 1822|     78|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
_ZN4args5Group5ResetEv:
 1951|    948|            {
 1952|    948|                Base::Reset();
 1953|       |
 1954|    948|                for (auto &child: Children())
  ------------------
  |  Branch (1954:33): [True: 2.84k, False: 948]
  ------------------
 1955|  2.84k|                {
 1956|  2.84k|                    child->Reset();
 1957|  2.84k|                }
 1958|       |#ifdef ARGS_NOEXCEPT
 1959|       |                error = Error::None;
 1960|       |                errorMsg.clear();
 1961|       |#endif
 1962|    948|            }
_ZN4args7Command5ResetEv:
 2667|    948|            {
 2668|    948|                Group::Reset();
 2669|    948|                selectedCommand = nullptr;
 2670|    948|                subparserProgramLine.clear();
 2671|    948|                subparserDescription.clear();
 2672|    948|                subparserHasFlag = false;
 2673|    948|                subparserHasPositional = false;
 2674|    948|                subparserHasCommand = false;
 2675|       |#ifdef ARGS_NOEXCEPT
 2676|       |                subparserError = Error::None;
 2677|       |#endif
 2678|    948|            }
_ZN4args7Command11DescriptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2288|    948|            { this->description = description_; }
_ZN4args7Command6EpilogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2298|    948|            { this->epilog = epilog_; }
_ZN4args14ArgumentParser10LongPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3435|    948|            {
 3436|    948|                this->longprefix = longprefix_;
 3437|    948|                this->helpParams.longPrefix = longprefix_;
 3438|    948|            }
_ZN4args14ArgumentParser11ShortPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3447|    948|            {
 3448|    948|                this->shortprefix = shortprefix_;
 3449|    948|                this->helpParams.shortPrefix = shortprefix_;
 3450|    948|            }
_ZN4args14ArgumentParser13LongSeparatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3459|    948|            {
 3460|    948|                if (longseparator_.empty())
  ------------------
  |  Branch (3460:21): [True: 0, False: 948]
  ------------------
 3461|      0|                {
 3462|      0|                    const std::string errorMessage("longseparator can not be set to empty");
 3463|       |#ifdef ARGS_NOEXCEPT
 3464|       |                    error = Error::Usage;
 3465|       |                    errorMsg = errorMessage;
 3466|       |#else
 3467|      0|                    throw UsageError(errorMessage);
 3468|      0|#endif
 3469|      0|                } else
 3470|    948|                {
 3471|    948|                    this->longseparator = longseparator_;
 3472|    948|                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3472:54): [True: 948, False: 0]
  ------------------
 3473|    948|                }
 3474|    948|            }
_ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  480|    922|            Error(const std::string &problem) : std::runtime_error(problem) {}
_ZN4args14ArgumentParser10TerminatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3483|    948|            { this->terminator = terminator_; }
_ZN4args14ArgumentParser22SetArgumentSeparationsEbbbb:
 3513|    948|            {
 3514|    948|                this->allowJoinedShortValue = allowJoinedShortValue_;
 3515|    948|                this->allowJoinedLongValue = allowJoinedLongValue_;
 3516|    948|                this->allowSeparateShortValue = allowSeparateShortValue_;
 3517|    948|                this->allowSeparateLongValue = allowSeparateLongValue_;
 3518|       |
 3519|    948|                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3519:50): [True: 948, False: 0]
  ------------------
 3520|    948|                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
  ------------------
  |  Branch (3520:51): [True: 948, False: 0]
  ------------------
 3521|    948|            }
_ZNK4args7Command7MatchedEv:
 2321|  24.2k|            { return Base::Matched(); }
_ZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2616|     26|            {
 2617|     26|                if (!Matched())
  ------------------
  |  Branch (2617:21): [True: 0, False: 26]
  ------------------
 2618|      0|                {
 2619|      0|                    return;
 2620|      0|                }
 2621|       |
 2622|     26|                auto onValidationError = [&]
 2623|     26|                {
 2624|     26|                    std::ostringstream problem;
 2625|     26|                    problem << "Group validation failed somewhere!";
 2626|       |#ifdef ARGS_NOEXCEPT
 2627|       |                    error = Error::Validation;
 2628|       |                    errorMsg = problem.str();
 2629|       |#else
 2630|     26|                    throw ValidationError(problem.str());
 2631|     26|#endif
 2632|     26|                };
 2633|       |
 2634|     26|                for (Base *child: Children())
  ------------------
  |  Branch (2634:33): [True: 78, False: 26]
  ------------------
 2635|     78|                {
 2636|     78|                    if (child->IsGroup() && !child->Matched())
  ------------------
  |  Branch (2636:25): [True: 0, False: 78]
  |  Branch (2636:45): [True: 0, False: 0]
  ------------------
 2637|      0|                    {
 2638|      0|                        onValidationError();
 2639|      0|                    }
 2640|       |
 2641|     78|                    child->Validate(shortprefix, longprefix);
 2642|     78|                }
 2643|       |
 2644|     26|                if (subparser != nullptr)
  ------------------
  |  Branch (2644:21): [True: 0, False: 26]
  ------------------
 2645|      0|                {
 2646|      0|                    subparser->Validate(shortprefix, longprefix);
 2647|      0|                    if (!subparser->Matched())
  ------------------
  |  Branch (2647:25): [True: 0, False: 0]
  ------------------
 2648|      0|                    {
 2649|      0|                        onValidationError();
 2650|      0|                    }
 2651|      0|                }
 2652|       |
 2653|     26|                if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
  ------------------
  |  Branch (2653:21): [True: 26, False: 0]
  |  Branch (2653:51): [True: 26, False: 0]
  |  Branch (2653:73): [True: 0, False: 26]
  |  Branch (2653:96): [True: 0, False: 26]
  ------------------
 2654|      0|                {
 2655|      0|                    std::ostringstream problem;
 2656|      0|                    problem << "Command is required";
 2657|       |#ifdef ARGS_NOEXCEPT
 2658|       |                    error = Error::Validation;
 2659|       |                    errorMsg = problem.str();
 2660|       |#else
 2661|      0|                    throw ValidationError(problem.str());
 2662|      0|#endif
 2663|      0|                }
 2664|     26|            }
_ZN4args7Command11GetCommandsEv:
 2519|    948|            {
 2520|    948|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2520:21): [True: 0, False: 948]
  ------------------
 2521|      0|                {
 2522|      0|                    return selectedCommand->GetCommands();
 2523|      0|                }
 2524|       |
 2525|    948|                if (Matched())
  ------------------
  |  Branch (2525:21): [True: 948, False: 0]
  ------------------
 2526|    948|                {
 2527|    948|                    return Group::GetCommands();
 2528|    948|                }
 2529|       |
 2530|      0|                return { this };
 2531|    948|            }
_ZN4args7Command5MatchERKNS_10EitherFlagE:
 2340|  22.9k|            {
 2341|  22.9k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2341:21): [True: 0, False: 22.9k]
  ------------------
 2342|      0|                {
 2343|      0|                    if (auto *res = selectedCommand->Match(flag))
  ------------------
  |  Branch (2343:31): [True: 0, False: 0]
  ------------------
 2344|      0|                    {
 2345|      0|                        return res;
 2346|      0|                    }
 2347|       |
 2348|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (2348:37): [True: 0, False: 0]
  ------------------
 2349|      0|                    {
 2350|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (2350:29): [True: 0, False: 0]
  ------------------
 2351|      0|                        {
 2352|      0|                            if (auto *res = child->Match(flag))
  ------------------
  |  Branch (2352:39): [True: 0, False: 0]
  ------------------
 2353|      0|                            {
 2354|      0|                                return res;
 2355|      0|                            }
 2356|      0|                        }
 2357|      0|                    }
 2358|       |
 2359|      0|                    return nullptr;
 2360|      0|                }
 2361|       |
 2362|  22.9k|                if (subparser != nullptr)
  ------------------
  |  Branch (2362:21): [True: 0, False: 22.9k]
  ------------------
 2363|      0|                {
 2364|      0|                    return subparser->Match(flag);
 2365|      0|                }
 2366|       |
 2367|  22.9k|                return Matched() ? Group::Match(flag) : nullptr;
  ------------------
  |  Branch (2367:24): [True: 22.9k, False: 0]
  ------------------
 2368|  22.9k|            }
_ZN4args7Command17GetNextPositionalEv:
 2404|    236|            {
 2405|    236|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2405:21): [True: 0, False: 236]
  ------------------
 2406|      0|                {
 2407|      0|                    if (auto *res = selectedCommand->GetNextPositional())
  ------------------
  |  Branch (2407:31): [True: 0, False: 0]
  ------------------
 2408|      0|                    {
 2409|      0|                        return res;
 2410|      0|                    }
 2411|       |
 2412|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (2412:37): [True: 0, False: 0]
  ------------------
 2413|      0|                    {
 2414|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (2414:29): [True: 0, False: 0]
  ------------------
 2415|      0|                        {
 2416|      0|                            if (auto *res = child->GetNextPositional())
  ------------------
  |  Branch (2416:39): [True: 0, False: 0]
  ------------------
 2417|      0|                            {
 2418|      0|                                return res;
 2419|      0|                            }
 2420|      0|                        }
 2421|      0|                    }
 2422|       |
 2423|      0|                    return nullptr;
 2424|      0|                }
 2425|       |
 2426|    236|                if (subparser != nullptr)
  ------------------
  |  Branch (2426:21): [True: 0, False: 236]
  ------------------
 2427|      0|                {
 2428|      0|                    return subparser->GetNextPositional();
 2429|      0|                }
 2430|       |
 2431|    236|                return Matched() ? Group::GetNextPositional() : nullptr;
  ------------------
  |  Branch (2431:24): [True: 236, False: 0]
  ------------------
 2432|    236|            }
_ZN4args14ArgumentParser5ResetEv:
 3651|    948|            {
 3652|    948|                Command::Reset();
 3653|    948|                matched = true;
 3654|    948|                readCompletion = false;
 3655|    948|            }
_ZN4args10EitherFlagC2Ec:
  575|  31.0k|        EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
_ZN4args10EitherFlagC2EPKc:
  574|  2.84k|        EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args7MatcherC2ESt16initializer_listINS_10EitherFlagEE:
  680|  2.84k|                Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
_ZN4args10EitherFlag8GetShortESt16initializer_listIS0_E:
  595|  2.84k|        {
  596|  2.84k|            std::unordered_set<char>  shortFlags;
  597|  2.84k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (597:40): [True: 5.68k, False: 2.84k]
  ------------------
  598|  5.68k|            {
  599|  5.68k|                if (flag.isShort)
  ------------------
  |  Branch (599:21): [True: 2.84k, False: 2.84k]
  ------------------
  600|  2.84k|                {
  601|  2.84k|                    shortFlags.insert(flag.shortFlag);
  602|  2.84k|                }
  603|  5.68k|            }
  604|  2.84k|            return shortFlags;
  605|  2.84k|        }
_ZN4args10EitherFlag7GetLongESt16initializer_listIS0_E:
  580|  2.84k|        {
  581|  2.84k|            std::unordered_set<std::string>  longFlags;
  582|  2.84k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (582:40): [True: 5.68k, False: 2.84k]
  ------------------
  583|  5.68k|            {
  584|  5.68k|                if (!flag.isShort)
  ------------------
  |  Branch (584:21): [True: 2.84k, False: 2.84k]
  ------------------
  585|  2.84k|                {
  586|  2.84k|                    longFlags.insert(flag.longFlag);
  587|  2.84k|                }
  588|  5.68k|            }
  589|  2.84k|            return longFlags;
  590|  2.84k|        }
_ZN4args7MatcherC2INSt3__113unordered_setIcNS2_4hashIcEENS2_8equal_toIcEENS2_9allocatorIcEEEENS3_INS2_12basic_stringIcNS2_11char_traitsIcEES9_EENS4_ISE_EENS6_ISE_EENS8_ISE_EEEEEEOT_OT0_:
  664|  2.84k|                Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
  665|  2.84k|            {}
_ZN4args7MatcherC2INSt3__121__hash_const_iteratorIPNS2_11__hash_nodeIcPvEEEENS3_IPNS4_INS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES5_EEEEEET_SI_T0_SJ_:
  639|  2.84k|                shortFlags(shortFlagsStart, shortFlagsEnd),
  640|  2.84k|                longFlags(longFlagsStart, longFlagsEnd)
  641|  2.84k|            {
  642|  2.84k|                if (shortFlags.empty() && longFlags.empty())
  ------------------
  |  Branch (642:21): [True: 0, False: 2.84k]
  |  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.84k|            }
_ZN4args8HelpFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE:
 3803|    948|            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:
 3768|  2.84k|            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
 3769|  2.84k|            {
 3770|  2.84k|                group_.Add(*this);
 3771|  2.84k|            }
_ZN4args8FlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE:
 1336|  2.84k|            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.84k|            NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
_ZN4args9NamedBaseD2Ev:
 1186|  2.84k|            virtual ~NamedBase() {}
_ZN4args7MatcherC2EOS0_:
  682|  2.84k|            Matcher(Matcher &&other) noexcept : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
  683|  2.84k|            {}
_ZN4args5Group3AddERNS_4BaseE:
 1714|  2.84k|            {
 1715|  2.84k|                children.emplace_back(&child);
 1716|       |
 1717|  2.84k|                if(child.IsFlag()) {
  ------------------
  |  Branch (1717:20): [True: 2.84k, False: 0]
  ------------------
 1718|  2.84k|#ifndef ARGS_NOEXCEPT
 1719|       |                    // Detection runs from the child's own constructor, so a
 1720|       |                    // duplicate throws before that constructor completes and the
 1721|       |                    // child's storage is released while the stack unwinds. Undo
 1722|       |                    // the registration first, or a caller that catches the error
 1723|       |                    // leaves this group holding a pointer to a dead object.
 1724|  2.84k|                    try
 1725|  2.84k|                    {
 1726|  2.84k|                        SignalDetectDuplicates();
 1727|  2.84k|                    }
 1728|  2.84k|                    catch (...)
 1729|  2.84k|                    {
 1730|      0|                        children.pop_back();
 1731|      0|                        throw;
 1732|      0|                    }
 1733|       |#else
 1734|       |                    SignalDetectDuplicates();
 1735|       |#endif
 1736|  2.84k|                }
 1737|  2.84k|            }
_ZN4args5Group22SignalDetectDuplicatesEv:
 1968|  2.84k|            {
 1969|  2.84k|                if(parent != nullptr) parent->SignalDetectDuplicates();
  ------------------
  |  Branch (1969:20): [True: 0, False: 2.84k]
  ------------------
 1970|  2.84k|                else DetectDuplicateFlags();
 1971|  2.84k|            }
_ZN4args5Group20DetectDuplicateFlagsEv:
 1978|  2.84k|            {
 1979|  2.84k|                std::unordered_set<char> usedShortFlags;
 1980|  2.84k|                std::unordered_set<std::string> usedLongFlags;
 1981|  2.84k|                DetectDuplicateFlags(usedShortFlags, usedLongFlags);
 1982|  2.84k|            }
_ZN4args5Group20DetectDuplicateFlagsERNSt3__113unordered_setIcNS1_4hashIcEENS1_8equal_toIcEENS1_9allocatorIcEEEERNS2_INS1_12basic_stringIcNS1_11char_traitsIcEES8_EENS3_ISE_EENS5_ISE_EENS7_ISE_EEEE:
 1987|  2.84k|            {
 1988|  2.84k|                for (Base *child: Children())
  ------------------
  |  Branch (1988:33): [True: 5.68k, False: 2.84k]
  ------------------
 1989|  5.68k|                {
 1990|  5.68k|                    if(auto flag = dynamic_cast<FlagBase*>(child))
  ------------------
  |  Branch (1990:29): [True: 5.68k, False: 0]
  ------------------
 1991|  5.68k|                    {
 1992|       |                        // Check for duplicate flags, setting a usage error on the
 1993|       |                        // flag if a duplicate is detected.
 1994|  5.68k|                        for(EitherFlag flagString: flag->GetMatcher().GetFlagStrings())
  ------------------
  |  Branch (1994:50): [True: 11.3k, False: 5.68k]
  ------------------
 1995|  11.3k|                        {
 1996|  11.3k|                            if(flagString.isShort)
  ------------------
  |  Branch (1996:32): [True: 5.68k, False: 5.68k]
  ------------------
 1997|  5.68k|                            {
 1998|  5.68k|                                if(usedShortFlags.count(flagString.shortFlag))
  ------------------
  |  Branch (1998:36): [True: 0, False: 5.68k]
  ------------------
 1999|      0|                                {
 2000|       |#ifdef ARGS_NOEXCEPT
 2001|       |                                    flag->SetUsageError();
 2002|       |#else
 2003|      0|                                    throw ParseError("duplicate short flag detected");
 2004|      0|#endif
 2005|      0|                                }
 2006|  5.68k|                                else
 2007|  5.68k|                                {
 2008|  5.68k|                                    usedShortFlags.insert(flagString.shortFlag);
 2009|  5.68k|                                }
 2010|  5.68k|                            }
 2011|  5.68k|                            else
 2012|  5.68k|                            {
 2013|  5.68k|                                if(usedLongFlags.count(flagString.longFlag))
  ------------------
  |  Branch (2013:36): [True: 0, False: 5.68k]
  ------------------
 2014|      0|                                {
 2015|       |#ifdef ARGS_NOEXCEPT
 2016|       |                                    flag->SetUsageError();
 2017|       |#else
 2018|      0|                                    throw ParseError("duplicate long flag detected");
 2019|      0|#endif
 2020|      0|                                }
 2021|  5.68k|                                else
 2022|  5.68k|                                {
 2023|  5.68k|                                    usedLongFlags.insert(flagString.longFlag);
 2024|  5.68k|                                }
 2025|  5.68k|                            }
 2026|  11.3k|                        }
 2027|  5.68k|                    }
 2028|      0|                    else if(auto group = dynamic_cast<Group*>(child))
  ------------------
  |  Branch (2028:34): [True: 0, False: 0]
  ------------------
 2029|      0|                    {
 2030|       |                        // A command opens its own flag namespace and runs its
 2031|       |                        // own duplicate detection as a separate root, so a flag
 2032|       |                        // reused either side of a command boundary is not a
 2033|       |                        // genuine duplicate. Only descend into plain groups
 2034|       |                        // here; IsGroup() is false for a Command.
 2035|      0|                        if(group->IsGroup())
  ------------------
  |  Branch (2035:28): [True: 0, False: 0]
  ------------------
 2036|      0|                        {
 2037|      0|                            group->DetectDuplicateFlags(usedShortFlags, usedLongFlags);
 2038|      0|                        }
 2039|      0|                    }
 2040|  5.68k|                }
 2041|  2.84k|            }
_ZNK4args8FlagBase10GetMatcherEv:
 1372|  5.68k|            {
 1373|  5.68k|                return matcher;
 1374|  5.68k|            }
_ZNK4args7Matcher14GetFlagStringsEv:
  711|  5.68k|            {
  712|  5.68k|                std::vector<EitherFlag> flagStrings;
  713|  5.68k|                flagStrings.reserve(shortFlags.size() + longFlags.size());
  714|  5.68k|                for (const char flag: shortFlags)
  ------------------
  |  Branch (714:37): [True: 5.68k, False: 5.68k]
  ------------------
  715|  5.68k|                {
  716|  5.68k|                    flagStrings.emplace_back(flag);
  717|  5.68k|                }
  718|  5.68k|                for (const std::string &flag: longFlags)
  ------------------
  |  Branch (718:45): [True: 5.68k, False: 5.68k]
  ------------------
  719|  5.68k|                {
  720|  5.68k|                    flagStrings.emplace_back(flag);
  721|  5.68k|                }
  722|  5.68k|                return flagStrings;
  723|  5.68k|            }
_ZN4args10EitherFlagC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  573|  6.19k|        EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  498|    907|            ParseError(const std::string &problem) : Error(problem) {}
_ZN4args8FlagBaseD2Ev:
 1338|  2.84k|            virtual ~FlagBase() {}
_ZN4args4Flag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3792|  22.3k|            {
 3793|  22.3k|            }
_ZNK4args8FlagBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 1377|     78|            {
 1378|     78|                if (!Matched() && IsRequired())
  ------------------
  |  Branch (1378:21): [True: 37, False: 41]
  |  Branch (1378:35): [True: 0, False: 37]
  ------------------
 1379|      0|                {
 1380|      0|                        std::ostringstream problem;
 1381|      0|                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
 1382|       |#ifdef ARGS_NOEXCEPT
 1383|       |                        error = Error::Required;
 1384|       |                        errorMsg = problem.str();
 1385|       |#else
 1386|      0|                        throw RequiredError(problem.str());
 1387|      0|#endif
 1388|      0|                }
 1389|     78|            }
_ZNK4args4Base10IsRequiredEv:
 1033|     37|            {
 1034|     37|                return (GetOptions() & Options::Required) != Options::None;
 1035|     37|            }
_ZNK4args8FlagBase6IsFlagEv:
 1341|  2.84k|            {
 1342|  2.84k|                return true;
 1343|  2.84k|            }
_ZN4args8FlagBase5MatchERKNS_10EitherFlagE:
 1346|  66.8k|            {
 1347|  66.8k|                if (matcher.Match(flag))
  ------------------
  |  Branch (1347:21): [True: 22.3k, False: 44.5k]
  ------------------
 1348|  22.3k|                {
 1349|  22.3k|                    if ((GetOptions() & Options::Single) != Options::None && matched)
  ------------------
  |  Branch (1349:25): [True: 0, False: 22.3k]
  |  Branch (1349:78): [True: 0, False: 0]
  ------------------
 1350|      0|                    {
 1351|      0|                        std::ostringstream problem;
 1352|      0|                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
 1353|       |#ifdef ARGS_NOEXCEPT
 1354|       |                        error = Error::Extra;
 1355|       |                        errorMsg = problem.str();
 1356|       |#else
 1357|      0|                        throw ExtraError(problem.str());
 1358|      0|#endif
 1359|      0|                    }
 1360|  22.3k|                    matched = true;
 1361|  22.3k|                    return this;
 1362|  22.3k|                }
 1363|  44.5k|                return nullptr;
 1364|  66.8k|            }
_ZNK4args7Matcher5MatchERKNS_10EitherFlagE:
  704|  66.8k|            {
  705|  66.8k|                return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
  ------------------
  |  Branch (705:24): [True: 65.4k, False: 1.41k]
  ------------------
  706|  66.8k|            }
_ZNK4args7Matcher5MatchEc:
  690|  65.4k|            {
  691|  65.4k|                return shortFlags.find(flag) != shortFlags.end();
  692|  65.4k|            }
_ZNK4args7Matcher5MatchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  697|  1.41k|            {
  698|  1.41k|                return longFlags.find(flag) != longFlags.end();
  699|  1.41k|            }
_ZN4args5NargsC2Em:
  992|  22.3k|        Nargs(size_t num_) : min{num_}, max{num_}
  993|  22.3k|        {
  994|  22.3k|        }
_ZNK4args9NamedBase4NameEv:
 1234|     15|            {
 1235|     15|                return name;
 1236|     15|            }
_ZNK4args4Flag17NumberOfArgumentsEv:
 3787|  22.3k|            {
 3788|  22.3k|                return 0;
 3789|  22.3k|            }
_ZN4args8HelpFlag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3808|     15|            {
 3809|       |#ifdef ARGS_NOEXCEPT
 3810|       |                    error = Error::Help;
 3811|       |                    errorMsg = Name();
 3812|       |#else
 3813|     15|                    throw Help(Name());
 3814|     15|#endif
 3815|     15|            }
_ZN4args4HelpC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  543|     15|            Help(const std::string &flag) : Error(flag) {}
_ZN4args7MatcherD2Ev:
  685|  5.68k|            ~Matcher() {}
_ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEb:
 3773|  1.89k|            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 (3773:186): [True: 0, False: 1.89k]
  ------------------
 3774|  1.89k|            {
 3775|  1.89k|            }
_ZN4args14ArgumentParser9ParseArgsINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3665|    948|            {
 3666|       |                // Reset all Matched statuses and errors
 3667|    948|                Reset();
 3668|       |#ifdef ARGS_NOEXCEPT
 3669|       |                error = GetError();
 3670|       |                if (error != Error::None)
 3671|       |                {
 3672|       |                    return end;
 3673|       |                }
 3674|       |#endif
 3675|    948|                return Parse(begin, end);
 3676|    948|            }
_ZN4args14ArgumentParser5ParseINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3185|    948|            {
 3186|    948|                bool terminated = false;
 3187|    948|                std::vector<Command *> commands = GetCommands();
 3188|       |
 3189|       |                // Check all arg chunks
 3190|  2.03k|                for (auto it = begin; it != end; ++it)
  ------------------
  |  Branch (3190:39): [True: 1.31k, False: 712]
  ------------------
 3191|  1.31k|                {
 3192|  1.31k|                    if (Complete(it, end, terminated))
  ------------------
  |  Branch (3192:25): [True: 0, False: 1.31k]
  ------------------
 3193|      0|                    {
 3194|      0|                        return end;
 3195|      0|                    }
 3196|       |
 3197|  1.31k|                    const auto &chunk = *it;
 3198|       |
 3199|  1.31k|                    if (!terminated && chunk == terminator)
  ------------------
  |  Branch (3199:25): [True: 1.31k, False: 3]
  |  Branch (3199:40): [True: 6, False: 1.30k]
  ------------------
 3200|      6|                    {
 3201|      6|                        terminated = true;
 3202|  1.31k|                    } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
  ------------------
  |  Branch (3202:32): [True: 1.30k, False: 3]
  |  Branch (3202:47): [True: 504, False: 805]
  ------------------
 3203|    504|                    {
 3204|    504|                        if (!ParseLong(it, end))
  ------------------
  |  Branch (3204:29): [True: 0, False: 504]
  ------------------
 3205|      0|                        {
 3206|      0|                            return it;
 3207|      0|                        }
 3208|    808|                    } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
  ------------------
  |  Branch (3208:32): [True: 805, False: 3]
  |  Branch (3208:47): [True: 572, False: 233]
  ------------------
 3209|    572|                    {
 3210|    572|                        if (!ParseShort(it, end))
  ------------------
  |  Branch (3210:29): [True: 0, False: 572]
  ------------------
 3211|      0|                        {
 3212|      0|                            return it;
 3213|      0|                        }
 3214|    572|                    } else if (!terminated && !commands.empty())
  ------------------
  |  Branch (3214:32): [True: 233, False: 3]
  |  Branch (3214:47): [True: 0, False: 233]
  ------------------
 3215|      0|                    {
 3216|      0|                        auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
 3217|      0|                        if (itCommand == commands.end())
  ------------------
  |  Branch (3217:29): [True: 0, False: 0]
  ------------------
 3218|      0|                        {
 3219|      0|                            const std::string errorMessage("Unknown command: " + chunk);
 3220|      0|#ifndef ARGS_NOEXCEPT
 3221|      0|                            throw ParseError(errorMessage);
 3222|       |#else
 3223|       |                            error = Error::Parse;
 3224|       |                            errorMsg = errorMessage;
 3225|       |                            return it;
 3226|       |#endif
 3227|      0|                        }
 3228|       |
 3229|      0|                        SelectCommand(*itCommand);
 3230|       |
 3231|      0|                        if (const auto &coroutine = GetCoroutine())
  ------------------
  |  Branch (3231:41): [True: 0, False: 0]
  ------------------
 3232|      0|                        {
 3233|      0|                            ++it;
 3234|      0|                            RaiiSubparser coro(*this, std::vector<std::string>(it, end));
 3235|      0|                            coroutine(coro.Parser());
 3236|       |#ifdef ARGS_NOEXCEPT
 3237|       |                            error = GetError();
 3238|       |                            if (error != Error::None)
 3239|       |                            {
 3240|       |                                return end;
 3241|       |                            }
 3242|       |
 3243|       |                            if (!coro.Parser().IsParsed())
 3244|       |                            {
 3245|       |                                error = Error::Usage;
 3246|       |                                return end;
 3247|       |                            }
 3248|       |#else
 3249|      0|                            if (!coro.Parser().IsParsed())
  ------------------
  |  Branch (3249:33): [True: 0, False: 0]
  ------------------
 3250|      0|                            {
 3251|      0|                                throw UsageError("Subparser::Parse was not called");
 3252|      0|                            }
 3253|      0|#endif
 3254|       |
 3255|      0|                            break;
 3256|      0|                        }
 3257|       |
 3258|      0|                        commands = GetCommands();
 3259|      0|                    } else
 3260|    236|                    {
 3261|    236|                        auto pos = GetNextPositional();
 3262|    236|                        if (pos)
  ------------------
  |  Branch (3262:29): [True: 0, False: 236]
  ------------------
 3263|      0|                        {
 3264|      0|                            pos->ParseValue(chunk);
 3265|       |#ifdef ARGS_NOEXCEPT
 3266|       |                            if (pos->GetError() != Error::None)
 3267|       |                            {
 3268|       |                                return it;
 3269|       |                            }
 3270|       |#endif
 3271|       |
 3272|      0|                            if (pos->KickOut())
  ------------------
  |  Branch (3272:33): [True: 0, False: 0]
  ------------------
 3273|      0|                            {
 3274|      0|                                return ++it;
 3275|      0|                            }
 3276|      0|                        } else
 3277|    236|                        {
 3278|    236|                            const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
 3279|    236|#ifndef ARGS_NOEXCEPT
 3280|    236|                            throw ParseError(errorMessage);
 3281|       |#else
 3282|       |                            error = Error::Parse;
 3283|       |                            errorMsg = errorMessage;
 3284|       |                            return it;
 3285|       |#endif
 3286|    236|                        }
 3287|    236|                    }
 3288|       |
 3289|  1.08k|                    if (!readCompletion && completion != nullptr && completion->Matched())
  ------------------
  |  Branch (3289:25): [True: 396, False: 686]
  |  Branch (3289:44): [True: 0, False: 396]
  |  Branch (3289:69): [True: 0, False: 0]
  ------------------
 3290|      0|                    {
 3291|       |#ifdef ARGS_NOEXCEPT
 3292|       |                        if (completion->GetError() != Error::None)
 3293|       |                        {
 3294|       |                            error = completion->GetError();
 3295|       |                            if (errorMsg.empty())
 3296|       |                            {
 3297|       |                                errorMsg = completion->GetErrorMsg();
 3298|       |                            }
 3299|       |                            return it;
 3300|       |                        }
 3301|       |
 3302|       |                        error = Error::Completion;
 3303|       |#endif
 3304|      0|                        readCompletion = true;
 3305|      0|                        ++it;
 3306|      0|                        const auto argsLeft = static_cast<size_t>(std::distance(it, end));
 3307|      0|                        if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
  ------------------
  |  Branch (3307:29): [True: 0, False: 0]
  |  Branch (3307:55): [True: 0, False: 0]
  |  Branch (3307:72): [True: 0, False: 0]
  ------------------
 3308|      0|                        {
 3309|      0|#ifndef ARGS_NOEXCEPT
 3310|      0|                            throw Completion("");
 3311|       |#else
 3312|       |                            return end;
 3313|       |#endif
 3314|      0|                        }
 3315|       |
 3316|      0|                        ++it;
 3317|      0|                        std::vector<std::string> curArgs;
 3318|      0|                        curArgs.reserve(completion->cword);
 3319|      0|                        auto curIt = it;
 3320|      0|                        for (size_t idx = 0; idx < completion->cword && curIt != end; ++idx, ++curIt)
  ------------------
  |  Branch (3320:46): [True: 0, False: 0]
  |  Branch (3320:73): [True: 0, False: 0]
  ------------------
 3321|      0|                        {
 3322|      0|                            curArgs.push_back(*curIt);
 3323|      0|                        }
 3324|       |
 3325|      0|                        if (completion->syntax == "bash")
  ------------------
  |  Branch (3325:29): [True: 0, False: 0]
  ------------------
 3326|      0|                        {
 3327|       |                            // bash tokenizes --flag=value as --flag=value
 3328|       |                            // Security fix: Use size_t arithmetic throughout to avoid conversion issues
 3329|      0|                            for (size_t idx = 0; idx < curArgs.size(); )
  ------------------
  |  Branch (3329:50): [True: 0, False: 0]
  ------------------
 3330|      0|                            {
 3331|      0|                                if (idx > 0 && curArgs[idx] == "=")
  ------------------
  |  Branch (3331:37): [True: 0, False: 0]
  |  Branch (3331:48): [True: 0, False: 0]
  ------------------
 3332|      0|                                {
 3333|      0|                                    size_t prev_idx = idx - 1;  // Safe since we checked idx > 0
 3334|      0|                                    curArgs[prev_idx] += "=";
 3335|      0|                                    size_t next_idx = 0;
 3336|      0|                                    if (SafeAdd<size_t>(idx, static_cast<size_t>(1), next_idx) && next_idx < curArgs.size())
  ------------------
  |  Branch (3336:41): [True: 0, False: 0]
  |  Branch (3336:99): [True: 0, False: 0]
  ------------------
 3337|      0|                                    {
 3338|      0|                                        curArgs[prev_idx] += curArgs[next_idx];
 3339|       |                                        // Erase the '=' token and the following value token.
 3340|      0|                                        size_t erase_end = 0;
 3341|      0|                                        if (SafeAdd<size_t>(next_idx, static_cast<size_t>(1), erase_end))
  ------------------
  |  Branch (3341:45): [True: 0, False: 0]
  ------------------
 3342|      0|                                        {
 3343|      0|                                            typedef std::vector<std::string>::difference_type diff_t;
 3344|      0|                                            curArgs.erase(curArgs.begin() + static_cast<diff_t>(idx),
 3345|      0|                                                         curArgs.begin() + static_cast<diff_t>(erase_end));
 3346|      0|                                        }
 3347|      0|                                    } else
 3348|      0|                                    {
 3349|       |                                        // Safe erase of single '=' token at the end
 3350|      0|                                        typedef std::vector<std::string>::difference_type diff_t;
 3351|      0|                                        curArgs.erase(curArgs.begin() + static_cast<diff_t>(idx));
 3352|      0|                                    }
 3353|       |                                    // Do not increment idx - next element slides into current position
 3354|      0|                                } else
 3355|      0|                                {
 3356|      0|                                    ++idx;
 3357|      0|                                }
 3358|      0|                            }
 3359|       |
 3360|      0|                        }
 3361|      0|#ifndef ARGS_NOEXCEPT
 3362|      0|                        try
 3363|      0|                        {
 3364|      0|                            Parse(curArgs.begin(), curArgs.end());
 3365|      0|                            throw Completion("");
 3366|      0|                        }
 3367|      0|                        catch (Completion &)
 3368|      0|                        {
 3369|      0|                            throw;
 3370|      0|                        }
 3371|      0|                        catch (args::Error&)
 3372|      0|                        {
 3373|      0|                            throw Completion("");
 3374|      0|                        }
 3375|       |#else
 3376|       |                        // Discard the nested Parse's return value: it points
 3377|       |                        // into the local curArgs vector, which is destroyed
 3378|       |                        // when this function returns, leaving the caller with
 3379|       |                        // a dangling iterator that would be compared against
 3380|       |                        // the outer `end` in ParseCLI. Return the outer
 3381|       |                        // `end` instead so the iterator stays in the caller's
 3382|       |                        // container.
 3383|       |                        Parse(curArgs.begin(), curArgs.end());
 3384|       |                        error = Error::Completion;
 3385|       |                        errorMsg.clear();
 3386|       |                        return end;
 3387|       |#endif
 3388|      0|                    }
 3389|  1.08k|                }
 3390|       |
 3391|    712|                Validate(shortprefix, longprefix);
 3392|    712|                return end;
 3393|    948|            }
_ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbT_SC_b:
 3057|  1.31k|            {
 3058|  1.31k|                auto nextIt = it;
 3059|  1.31k|                if (!readCompletion || (++nextIt != end))
  ------------------
  |  Branch (3059:21): [True: 1.31k, False: 0]
  |  Branch (3059:40): [True: 0, False: 0]
  ------------------
 3060|  1.31k|                {
 3061|  1.31k|                    return false;
 3062|  1.31k|                }
 3063|       |
 3064|      0|                const auto &chunk = *it;
 3065|      0|                auto pos = GetNextPositional();
 3066|      0|                std::vector<Command *> commands = GetCommands();
 3067|      0|                const auto optionType = ParseOption(chunk, true);
 3068|       |
 3069|       |                // Once the terminator has been seen the parser treats every
 3070|       |                // following chunk as positional, so only positional choices are
 3071|       |                // valid completions here. Suggesting flags or commands past the
 3072|       |                // terminator offers candidates the parser would then reject.
 3073|      0|                if (!terminated && !commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
  ------------------
  |  Branch (3073:21): [True: 0, False: 0]
  |  Branch (3073:36): [True: 0, False: 0]
  |  Branch (3073:58): [True: 0, False: 0]
  |  Branch (3073:75): [True: 0, False: 0]
  ------------------
 3074|      0|                {
 3075|      0|                    for (auto &cmd : commands)
  ------------------
  |  Branch (3075:36): [True: 0, False: 0]
  ------------------
 3076|      0|                    {
 3077|      0|                        if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3077:29): [True: 0, False: 0]
  ------------------
 3078|      0|                        {
 3079|      0|                            AddCompletionReply(chunk, cmd->Name());
 3080|      0|                        }
 3081|      0|                    }
 3082|      0|                } else
 3083|      0|                {
 3084|      0|                    bool hasPositionalCompletion = true;
 3085|       |
 3086|      0|                    if (!terminated && !commands.empty())
  ------------------
  |  Branch (3086:25): [True: 0, False: 0]
  |  Branch (3086:40): [True: 0, False: 0]
  ------------------
 3087|      0|                    {
 3088|      0|                        for (auto &cmd : commands)
  ------------------
  |  Branch (3088:40): [True: 0, False: 0]
  ------------------
 3089|      0|                        {
 3090|      0|                            if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3090:33): [True: 0, False: 0]
  ------------------
 3091|      0|                            {
 3092|      0|                                AddCompletionReply(chunk, cmd->Name());
 3093|      0|                            }
 3094|      0|                        }
 3095|      0|                    } else if (pos)
  ------------------
  |  Branch (3095:32): [True: 0, False: 0]
  ------------------
 3096|      0|                    {
 3097|      0|                        if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3097:29): [True: 0, False: 0]
  ------------------
 3098|      0|                        {
 3099|      0|                            auto choices = pos->HelpChoices(helpParams);
 3100|      0|                            hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
  ------------------
  |  Branch (3100:55): [True: 0, False: 0]
  |  Branch (3100:75): [True: 0, False: 0]
  ------------------
 3101|      0|                            for (auto &choice : choices)
  ------------------
  |  Branch (3101:47): [True: 0, False: 0]
  ------------------
 3102|      0|                            {
 3103|      0|                                AddCompletionReply(chunk, choice);
 3104|      0|                            }
 3105|      0|                        }
 3106|      0|                    }
 3107|       |
 3108|      0|                    if (!terminated && hasPositionalCompletion)
  ------------------
  |  Branch (3108:25): [True: 0, False: 0]
  |  Branch (3108:40): [True: 0, False: 0]
  ------------------
 3109|      0|                    {
 3110|      0|                        auto flags = GetAllFlags();
 3111|      0|                        for (auto flag : flags)
  ------------------
  |  Branch (3111:40): [True: 0, False: 0]
  ------------------
 3112|      0|                        {
 3113|      0|                            if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
  ------------------
  |  Branch (3113:33): [True: 0, False: 0]
  ------------------
 3114|      0|                            {
 3115|      0|                                continue;
 3116|      0|                            }
 3117|       |
 3118|      0|                            auto &matcher = flag->GetMatcher();
 3119|      0|                            if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
  ------------------
  |  Branch (3119:33): [True: 0, False: 0]
  ------------------
 3120|      0|                            {
 3121|      0|                                for (auto &flagName : matcher.GetFlagStrings())
  ------------------
  |  Branch (3121:53): [True: 0, False: 0]
  ------------------
 3122|      0|                                {
 3123|      0|                                    if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
  ------------------
  |  Branch (3123:41): [True: 0, False: 0]
  ------------------
 3124|      0|                                    {
 3125|      0|                                        break;
 3126|      0|                                    }
 3127|      0|                                }
 3128|      0|                            }
 3129|      0|                        }
 3130|       |
 3131|      0|                        if (optionType == OptionType::LongFlag && allowJoinedLongValue)
  ------------------
  |  Branch (3131:29): [True: 0, False: 0]
  |  Branch (3131:67): [True: 0, False: 0]
  ------------------
 3132|      0|                        {
 3133|      0|                            const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
  ------------------
  |  Branch (3133:52): [True: 0, False: 0]
  ------------------
 3134|       |                            // Only attempt joined-value completion when the
 3135|       |                            // separator lies at or past the long prefix, so
 3136|       |                            // there is a (possibly empty) flag name between
 3137|       |                            // them. With a custom longseparator that overlaps
 3138|       |                            // the prefix (e.g. LongSeparator("-") under the
 3139|       |                            // default "--" prefix), an attacker-controlled
 3140|       |                            // completion word like "--x" puts the separator
 3141|       |                            // inside the prefix, making `arg` shorter than
 3142|       |                            // longprefix. arg.substr(longprefix.size()) would
 3143|       |                            // then throw std::out_of_range, which escapes the
 3144|       |                            // parser as a non-args exception (bypassing the
 3145|       |                            // documented catch(args::Error) idiom) and is
 3146|       |                            // thrown even under ARGS_NOEXCEPT.
 3147|      0|                            if (separator != chunk.npos && separator >= longprefix.size())
  ------------------
  |  Branch (3147:33): [True: 0, False: 0]
  |  Branch (3147:60): [True: 0, False: 0]
  ------------------
 3148|      0|                            {
 3149|      0|                                std::string arg(chunk, 0, separator);
 3150|      0|                                if (auto flag = this->Match(arg.substr(longprefix.size())))
  ------------------
  |  Branch (3150:42): [True: 0, False: 0]
  ------------------
 3151|      0|                                {
 3152|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (3152:55): [True: 0, False: 0]
  ------------------
 3153|      0|                                    {
 3154|      0|                                        AddCompletionReply(chunk, arg + longseparator + choice);
 3155|      0|                                    }
 3156|      0|                                }
 3157|      0|                            }
 3158|      0|                        } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
  ------------------
  |  Branch (3158:36): [True: 0, False: 0]
  |  Branch (3158:75): [True: 0, False: 0]
  ------------------
 3159|      0|                        {
 3160|      0|                            if (chunk.size() > shortprefix.size() + 1)
  ------------------
  |  Branch (3160:33): [True: 0, False: 0]
  ------------------
 3161|      0|                            {
 3162|      0|                                auto arg = chunk.at(shortprefix.size());
 3163|       |                                //TODO: support -abcVALUE where a and b take no value
 3164|      0|                                if (auto flag = this->Match(arg))
  ------------------
  |  Branch (3164:42): [True: 0, False: 0]
  ------------------
 3165|      0|                                {
 3166|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (3166:55): [True: 0, False: 0]
  ------------------
 3167|      0|                                    {
 3168|      0|                                        AddCompletionReply(chunk, shortprefix + arg + choice);
 3169|      0|                                    }
 3170|      0|                                }
 3171|      0|                            }
 3172|      0|                        }
 3173|      0|                    }
 3174|      0|                }
 3175|       |
 3176|      0|#ifndef ARGS_NOEXCEPT
 3177|      0|                throw Completion(completion->Get());
 3178|       |#else
 3179|       |                return true;
 3180|       |#endif
 3181|  1.31k|            }
_ZN4args14ArgumentParser11ParseOptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 2735|  2.11k|            {
 2736|  2.11k|                const bool matchesLong = s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length());
  ------------------
  |  Branch (2736:42): [True: 504, False: 1.61k]
  |  Branch (2736:70): [True: 0, False: 504]
  |  Branch (2736:84): [True: 504, False: 0]
  ------------------
 2737|  2.11k|                const bool matchesShort = s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length());
  ------------------
  |  Branch (2737:43): [True: 1.65k, False: 458]
  |  Branch (2737:72): [True: 0, False: 1.65k]
  |  Branch (2737:86): [True: 1.64k, False: 8]
  ------------------
 2738|       |
 2739|       |                // A chunk can start with both prefixes when one is a prefix of
 2740|       |                // the other, or when the long prefix is empty (every string
 2741|       |                // starts with it). Resolve to the longer, more specific prefix:
 2742|       |                // this keeps the default "--"/"-" preference for long flags
 2743|       |                // while letting a short flag be recognised under an empty long
 2744|       |                // prefix instead of being swallowed as a nameless long flag.
 2745|  2.11k|                if (matchesLong && matchesShort)
  ------------------
  |  Branch (2745:21): [True: 504, False: 1.61k]
  |  Branch (2745:36): [True: 504, False: 0]
  ------------------
 2746|    504|                {
 2747|    504|                    return longprefix.length() >= shortprefix.length() ? OptionType::LongFlag : OptionType::ShortFlag;
  ------------------
  |  Branch (2747:28): [True: 504, False: 0]
  ------------------
 2748|    504|                }
 2749|       |
 2750|  1.61k|                if (matchesLong)
  ------------------
  |  Branch (2750:21): [True: 0, False: 1.61k]
  ------------------
 2751|      0|                {
 2752|      0|                    return OptionType::LongFlag;
 2753|      0|                }
 2754|       |
 2755|  1.61k|                if (matchesShort)
  ------------------
  |  Branch (2755:21): [True: 1.14k, False: 466]
  ------------------
 2756|  1.14k|                {
 2757|  1.14k|                    return OptionType::ShortFlag;
 2758|  1.14k|                }
 2759|       |
 2760|    466|                return OptionType::Positional;
 2761|  1.61k|            }
_ZN4args14ArgumentParser9ParseLongINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2885|    504|            {
 2886|    504|                const auto &chunk = *it;
 2887|    504|                const auto argchunk = chunk.substr(longprefix.size());
 2888|       |                // Try to separate it, in case of a separator:
 2889|    504|                const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
  ------------------
  |  Branch (2889:40): [True: 0, False: 504]
  ------------------
 2890|       |                // If the separator is in the argument, separate it.
 2891|    504|                const auto arg = (separator != argchunk.npos ?
  ------------------
  |  Branch (2891:35): [True: 262, False: 242]
  ------------------
 2892|    262|                    std::string(argchunk, 0, separator)
 2893|    504|                    : argchunk);
 2894|    504|                const auto joined = (separator != argchunk.npos ?
  ------------------
  |  Branch (2894:38): [True: 262, False: 242]
  ------------------
 2895|    262|                    argchunk.substr(separator + longseparator.size())
 2896|    504|                    : std::string());
 2897|       |
 2898|    504|                if (auto flag = Match(arg))
  ------------------
  |  Branch (2898:26): [True: 82, False: 422]
  ------------------
 2899|     82|                {
 2900|       |#ifdef ARGS_NOEXCEPT
 2901|       |                    // Match() may set the flag's error (e.g. Error::Extra when
 2902|       |                    // Options::Single is violated). In non-noexcept mode that
 2903|       |                    // path throws and parsing stops before the value is read;
 2904|       |                    // in noexcept mode we must mirror that and skip the value
 2905|       |                    // parsing so the previously-stored value is preserved.
 2906|       |                    if (flag->GetError() != Error::None)
 2907|       |                    {
 2908|       |                        return false;
 2909|       |                    }
 2910|       |#endif
 2911|     82|                    std::vector<std::string> values;
 2912|     82|                    const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
 2913|     82|                                                                     separator != argchunk.npos, joined, false, values);
 2914|     82|                    if (!errorMessage.empty())
  ------------------
  |  Branch (2914:25): [True: 18, False: 64]
  ------------------
 2915|     18|                    {
 2916|     18|#ifndef ARGS_NOEXCEPT
 2917|     18|                        throw ParseError(errorMessage);
 2918|       |#else
 2919|       |                        error = Error::Parse;
 2920|       |                        errorMsg = errorMessage;
 2921|       |                        return false;
 2922|       |#endif
 2923|     18|                    }
 2924|       |
 2925|     64|                    if (!readCompletion)
  ------------------
  |  Branch (2925:25): [True: 64, False: 0]
  ------------------
 2926|     64|                    {
 2927|     64|                        flag->ParseValue(values);
 2928|       |#ifdef ARGS_NOEXCEPT
 2929|       |                        // Non-noexcept ParseValue paths throw on Help, reader
 2930|       |                        // failure, or Map miss, which halts parsing. Mirror
 2931|       |                        // that here so a later parser-level error (e.g. an
 2932|       |                        // unknown flag) cannot shadow the flag's error in
 2933|       |                        // ArgumentParser::GetError().
 2934|       |                        if (flag->GetError() != Error::None)
 2935|       |                        {
 2936|       |                            return false;
 2937|       |                        }
 2938|       |#endif
 2939|     64|                    }
 2940|       |
 2941|     64|                    if (flag->KickOut())
  ------------------
  |  Branch (2941:25): [True: 0, False: 64]
  ------------------
 2942|      0|                    {
 2943|      0|                        ++it;
 2944|      0|                        return false;
 2945|      0|                    }
 2946|     64|                } else
 2947|    422|                {
 2948|    422|                    const std::string errorMessage("Flag could not be matched: " + arg);
 2949|    422|#ifndef ARGS_NOEXCEPT
 2950|    422|                    throw ParseError(errorMessage);
 2951|       |#else
 2952|       |                    error = Error::Parse;
 2953|       |                    errorMsg = errorMessage;
 2954|       |                    return false;
 2955|       |#endif
 2956|    422|                }
 2957|       |
 2958|     64|                return true;
 2959|    504|            }
_ZN4args14ArgumentParser15ParseArgsValuesINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_RNS_8FlagBaseERKS9_RT_SG_bbbSF_bRNS2_6vectorIS9_NS7_IS9_EEEE:
 2799|  22.3k|            {
 2800|  22.3k|                values.clear();
 2801|       |
 2802|  22.3k|                Nargs nargs = flag.NumberOfArguments();
 2803|       |
 2804|  22.3k|                if (hasJoined && !allowJoined && (nargs.min != 0 || !canDiscardJoined))
  ------------------
  |  Branch (2804:21): [True: 21.9k, False: 393]
  |  Branch (2804:34): [True: 0, False: 21.9k]
  |  Branch (2804:51): [True: 0, False: 0]
  |  Branch (2804:69): [True: 0, False: 0]
  ------------------
 2805|      0|                {
 2806|      0|                    return "Flag '" + arg + "' was passed a joined argument, but these are disallowed";
 2807|      0|                }
 2808|       |
 2809|  22.3k|                if (hasJoined)
  ------------------
  |  Branch (2809:21): [True: 21.9k, False: 393]
  ------------------
 2810|  21.9k|                {
 2811|  21.9k|                    if (!canDiscardJoined || (allowJoined && nargs.max != 0))
  ------------------
  |  Branch (2811:25): [True: 18, False: 21.9k]
  |  Branch (2811:47): [True: 21.9k, False: 0]
  |  Branch (2811:62): [True: 0, False: 21.9k]
  ------------------
 2812|     18|                    {
 2813|     18|                        values.push_back(joinedArg);
 2814|     18|                    }
 2815|  21.9k|                } else if (!allowSeparate)
  ------------------
  |  Branch (2815:28): [True: 0, False: 393]
  ------------------
 2816|      0|                {
 2817|      0|                    if (nargs.min != 0)
  ------------------
  |  Branch (2817:25): [True: 0, False: 0]
  ------------------
 2818|      0|                    {
 2819|      0|                        return "Flag '" + arg + "' was passed a separate argument, but these are disallowed";
 2820|      0|                    }
 2821|      0|                }
 2822|       |
 2823|       |                // Only gather separate values when they are allowed. A joined
 2824|       |                // value that was discarded rather than taken (short chunks such
 2825|       |                // as -nf when joined short values are off) means this flag isn't
 2826|       |                // taking an argument here, so the rest of the chunk is flags.
 2827|  22.3k|                if (allowSeparate && (!hasJoined || !values.empty()))
  ------------------
  |  Branch (2827:21): [True: 22.3k, False: 0]
  |  Branch (2827:39): [True: 393, False: 21.9k]
  |  Branch (2827:53): [True: 18, False: 21.9k]
  ------------------
 2828|    411|                {
 2829|    411|                    auto valueIt = it;
 2830|    411|                    ++valueIt;
 2831|       |
 2832|    411|                    while (valueIt != end &&
  ------------------
  |  Branch (2832:28): [True: 381, False: 30]
  ------------------
 2833|    381|                           *valueIt != terminator &&
  ------------------
  |  Branch (2833:28): [True: 377, False: 4]
  ------------------
 2834|    377|                           values.size() < nargs.max &&
  ------------------
  |  Branch (2834:28): [True: 0, False: 377]
  ------------------
 2835|      0|                           (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional))
  ------------------
  |  Branch (2835:29): [True: 0, False: 0]
  |  Branch (2835:58): [True: 0, False: 0]
  ------------------
 2836|      0|                    {
 2837|      0|                        if (Complete(flag, valueIt, end))
  ------------------
  |  Branch (2837:29): [True: 0, False: 0]
  ------------------
 2838|      0|                        {
 2839|       |                            // Park `it` on the completion position rather than
 2840|       |                            // `end`. In ARGS_NOEXCEPT mode Complete returns
 2841|       |                            // true (no throw), so the caller's for-loop will
 2842|       |                            // run its ++it after we return; advancing an
 2843|       |                            // already-end iterator is undefined behavior and
 2844|       |                            // causes a subsequent out-of-bounds read of the
 2845|       |                            // arg vector. Since Complete only fires when
 2846|       |                            // ++nextIt == end, valueIt is the last element,
 2847|       |                            // and ++(it=valueIt) safely lands on end.
 2848|      0|                            it = valueIt;
 2849|      0|                            return "";
 2850|      0|                        }
 2851|       |
 2852|      0|                        values.push_back(*valueIt);
 2853|      0|                        ++it;
 2854|      0|                        ++valueIt;
 2855|      0|                    }
 2856|    411|                }
 2857|       |
 2858|  22.3k|                if (values.size() > nargs.max)
  ------------------
  |  Branch (2858:21): [True: 18, False: 22.3k]
  ------------------
 2859|     18|                {
 2860|     18|                    return "Passed an argument into a non-argument flag: " + arg;
 2861|  22.3k|                } else if (values.size() < nargs.min)
  ------------------
  |  Branch (2861:28): [True: 0, False: 22.3k]
  ------------------
 2862|      0|                {
 2863|      0|                    if (nargs.min == 1 && nargs.max == 1)
  ------------------
  |  Branch (2863:25): [True: 0, False: 0]
  |  Branch (2863:43): [True: 0, False: 0]
  ------------------
 2864|      0|                    {
 2865|      0|                        return "Flag '" + arg + "' requires an argument but received none";
 2866|      0|                    } else if (nargs.min == 1)
  ------------------
  |  Branch (2866:32): [True: 0, False: 0]
  ------------------
 2867|      0|                    {
 2868|      0|                        return "Flag '" + arg + "' requires at least one argument but received none";
 2869|      0|                    } else if (nargs.min != nargs.max)
  ------------------
  |  Branch (2869:32): [True: 0, False: 0]
  ------------------
 2870|      0|                    {
 2871|      0|                        return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
 2872|      0|                               " arguments but received " + std::to_string(values.size());
 2873|      0|                    } else
 2874|      0|                    {
 2875|      0|                        return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
 2876|      0|                               " arguments but received " + std::to_string(values.size());
 2877|      0|                    }
 2878|      0|                }
 2879|       |
 2880|  22.3k|                return {};
 2881|  22.3k|            }
_ZN4args14ArgumentParser10ParseShortINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2963|    572|            {
 2964|    572|                const auto &chunk = *it;
 2965|    572|                const auto argchunk = chunk.substr(shortprefix.size());
 2966|  22.8k|                for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
  ------------------
  |  Branch (2966:57): [True: 22.4k, False: 341]
  ------------------
 2967|  22.4k|                {
 2968|  22.4k|                    const auto arg = *argit;
 2969|       |
 2970|  22.4k|                    if (auto flag = Match(arg))
  ------------------
  |  Branch (2970:30): [True: 22.2k, False: 231]
  ------------------
 2971|  22.2k|                    {
 2972|       |#ifdef ARGS_NOEXCEPT
 2973|       |                        // See ParseLong: if Match recorded an error
 2974|       |                        // (e.g. Options::Single violation), bail before the
 2975|       |                        // value is parsed so the prior value is preserved.
 2976|       |                        if (flag->GetError() != Error::None)
 2977|       |                        {
 2978|       |                            return false;
 2979|       |                        }
 2980|       |#endif
 2981|  22.2k|                        const std::string value(argit + 1, std::end(argchunk));
 2982|  22.2k|                        std::vector<std::string> values;
 2983|  22.2k|                        const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
 2984|  22.2k|                                                                         allowSeparateShortValue, allowJoinedShortValue,
 2985|  22.2k|                                                                         !value.empty(), value, !value.empty(), values);
 2986|       |
 2987|  22.2k|                        if (!errorMessage.empty())
  ------------------
  |  Branch (2987:29): [True: 0, False: 22.2k]
  ------------------
 2988|      0|                        {
 2989|      0|#ifndef ARGS_NOEXCEPT
 2990|      0|                            throw ParseError(errorMessage);
 2991|       |#else
 2992|       |                            error = Error::Parse;
 2993|       |                            errorMsg = errorMessage;
 2994|       |                            return false;
 2995|       |#endif
 2996|      0|                        }
 2997|       |
 2998|  22.2k|                        if (!readCompletion)
  ------------------
  |  Branch (2998:29): [True: 22.2k, False: 0]
  ------------------
 2999|  22.2k|                        {
 3000|  22.2k|                            flag->ParseValue(values);
 3001|       |#ifdef ARGS_NOEXCEPT
 3002|       |                            // See ParseLong: ensure a flag-level error from
 3003|       |                            // ParseValue (Help, Parse, Map) halts parsing so
 3004|       |                            // it cannot be shadowed by a later parser error.
 3005|       |                            if (flag->GetError() != Error::None)
 3006|       |                            {
 3007|       |                                return false;
 3008|       |                            }
 3009|       |#endif
 3010|  22.2k|                        }
 3011|       |
 3012|  22.2k|                        if (flag->KickOut())
  ------------------
  |  Branch (3012:29): [True: 0, False: 22.2k]
  ------------------
 3013|      0|                        {
 3014|      0|                            ++it;
 3015|      0|                            return false;
 3016|      0|                        }
 3017|       |
 3018|  22.2k|                        if (!values.empty())
  ------------------
  |  Branch (3018:29): [True: 0, False: 22.2k]
  ------------------
 3019|      0|                        {
 3020|      0|                            break;
 3021|      0|                        }
 3022|  22.2k|                    } else
 3023|    231|                    {
 3024|    231|                        const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
 3025|    231|#ifndef ARGS_NOEXCEPT
 3026|    231|                        throw ParseError(errorMessage);
 3027|       |#else
 3028|       |                        error = Error::Parse;
 3029|       |                        errorMsg = errorMessage;
 3030|       |                        return false;
 3031|       |#endif
 3032|    231|                    }
 3033|  22.4k|                }
 3034|       |
 3035|    341|                return true;
 3036|    572|            }
_ZNK4args4Base7KickOutEv:
 1124|  22.3k|            {
 1125|  22.3k|                return (options & Options::KickOut) != Options::None;
 1126|  22.3k|            }

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