_ZN4args14ArgumentParserC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 3412|  1.74k|            {
 3413|  1.74k|                Description(description_);
 3414|  1.74k|                Epilog(epilog_);
 3415|  1.74k|                LongPrefix("--");
 3416|  1.74k|                ShortPrefix("-");
 3417|  1.74k|                LongSeparator("=");
 3418|  1.74k|                Terminator("--");
 3419|  1.74k|                SetArgumentSeparations(true, true, true, true);
 3420|  1.74k|                matched = true;
 3421|  1.74k|            }
_ZN4args7CommandC2Ev:
 2231|  1.74k|            Command() = default;
_ZN4args5GroupC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_8functionIFbRKS0_EEENS_7OptionsE:
 1715|  1.74k|            Group(const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_)
 1716|  1.74k|            {
 1717|  1.74k|                parent = nullptr;
 1718|  1.74k|            }
_ZN4args4BaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7OptionsE:
 1024|  29.5k|            Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
_ZNK4args4Base7MatchedEv:
 1038|  92.3k|            {
 1039|  92.3k|                return matched;
 1040|  92.3k|            }
_ZN4args4Base11GetCommandsEv:
 1060|  83.5k|            {
 1061|  83.5k|                return {};
 1062|  83.5k|            }
_ZNK4args4Base7IsGroupEv:
 1065|  52.3k|            {
 1066|  52.3k|                return false;
 1067|  52.3k|            }
_ZN4args4Base5MatchERKNS_10EitherFlagE:
 1075|    867|            {
 1076|    867|                return nullptr;
 1077|    867|            }
_ZN4args4Base17GetNextPositionalEv:
 1080|  56.5k|            {
 1081|  56.5k|                return nullptr;
 1082|  56.5k|            }
_ZNK4args4Base10HasCommandEv:
 1100|  27.8k|            {
 1101|  27.8k|                return false;
 1102|  27.8k|            }
_ZN4args4Base5ResetEv:
 1129|  73.0k|            {
 1130|  73.0k|                matched = false;
 1131|       |#ifdef ARGS_NOEXCEPT
 1132|       |                error = Error::None;
 1133|       |                errorMsg.clear();
 1134|       |#endif
 1135|  73.0k|            }
_ZN4args4BaseD2Ev:
 1025|  29.5k|            virtual ~Base() {}
_ZN4args5GroupD2Ev:
 1725|  1.74k|            virtual ~Group() {}
_ZNK4args5Group8ChildrenEv:
 1758|  49.4k|            {
 1759|  49.4k|                return children;
 1760|  49.4k|            }
_ZN4argsanENS_7OptionsES0_:
  809|  62.8k|    {
  810|  62.8k|        return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
  811|  62.8k|    }
_ZNK4args4Base10GetOptionsEv:
 1028|  55.1k|            {
 1029|  55.1k|                return options;
 1030|  55.1k|            }
_ZN4args5Group11GetCommandsEv:
 1951|  5.22k|            {
 1952|  5.22k|                std::vector<Command*> res;
 1953|  5.22k|                for (const auto &child : Children())
  ------------------
  |  Branch (1953:40): [True: 83.5k, False: 5.22k]
  ------------------
 1954|  83.5k|                {
 1955|  83.5k|                    auto subparsers = child->GetCommands();
 1956|  83.5k|                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
 1957|  83.5k|                }
 1958|  5.22k|                return res;
 1959|  5.22k|            }
_ZN4args5Group5MatchERKNS_10EitherFlagE:
 1768|  4.92k|            {
 1769|  4.92k|                for (Base *child: Children())
  ------------------
  |  Branch (1769:33): [True: 44.9k, False: 291]
  ------------------
 1770|  44.9k|                {
 1771|  44.9k|                    if (FlagBase *match = child->Match(flag))
  ------------------
  |  Branch (1771:35): [True: 4.62k, False: 40.3k]
  ------------------
 1772|  4.62k|                    {
 1773|  4.62k|                        return match;
 1774|  4.62k|                    }
 1775|  44.9k|                }
 1776|    291|                return nullptr;
 1777|  4.92k|            }
_ZN4args5Group17GetNextPositionalEv:
 1803|  4.35k|            {
 1804|  4.35k|                for (Base *child: Children())
  ------------------
  |  Branch (1804:33): [True: 62.4k, False: 0]
  ------------------
 1805|  62.4k|                {
 1806|  62.4k|                    if (auto next = child->GetNextPositional())
  ------------------
  |  Branch (1806:30): [True: 4.35k, False: 58.1k]
  ------------------
 1807|  4.35k|                    {
 1808|  4.35k|                        return next;
 1809|  4.35k|                    }
 1810|  62.4k|                }
 1811|      0|                return nullptr;
 1812|  4.35k|            }
_ZNK4args5Group10HasCommandEv:
 1837|  1.74k|            {
 1838|  1.74k|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
 1839|  1.74k|            }
_ZZNK4args5Group10HasCommandEvENKUlPNS_4BaseEE_clES2_:
 1838|  27.8k|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
_ZN4args5Group5ResetEv:
 1967|  5.22k|            {
 1968|  5.22k|                Base::Reset();
 1969|       |
 1970|  5.22k|                for (auto &child: Children())
  ------------------
  |  Branch (1970:33): [True: 83.5k, False: 5.22k]
  ------------------
 1971|  83.5k|                {
 1972|  83.5k|                    child->Reset();
 1973|  83.5k|                }
 1974|       |#ifdef ARGS_NOEXCEPT
 1975|       |                error = Error::None;
 1976|       |                errorMsg.clear();
 1977|       |#endif
 1978|  5.22k|            }
_ZN4args7Command5ResetEv:
 2683|  5.22k|            {
 2684|  5.22k|                Group::Reset();
 2685|  5.22k|                selectedCommand = nullptr;
 2686|  5.22k|                subparserProgramLine.clear();
 2687|  5.22k|                subparserDescription.clear();
 2688|  5.22k|                subparserHasFlag = false;
 2689|  5.22k|                subparserHasPositional = false;
 2690|  5.22k|                subparserHasCommand = false;
 2691|       |#ifdef ARGS_NOEXCEPT
 2692|       |                subparserError = Error::None;
 2693|       |#endif
 2694|  5.22k|            }
_ZN4args7Command11DescriptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2304|  1.74k|            { this->description = description_; }
_ZN4args7Command6EpilogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2314|  1.74k|            { this->epilog = epilog_; }
_ZN4args14ArgumentParser10LongPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3448|  1.74k|            {
 3449|  1.74k|                this->longprefix = longprefix_;
 3450|  1.74k|                this->helpParams.longPrefix = longprefix_;
 3451|  1.74k|            }
_ZN4args14ArgumentParser11ShortPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3460|  1.74k|            {
 3461|  1.74k|                this->shortprefix = shortprefix_;
 3462|  1.74k|                this->helpParams.shortPrefix = shortprefix_;
 3463|  1.74k|            }
_ZN4args14ArgumentParser13LongSeparatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3472|  1.74k|            {
 3473|  1.74k|                if (longseparator_.empty())
  ------------------
  |  Branch (3473:21): [True: 0, False: 1.74k]
  ------------------
 3474|      0|                {
 3475|      0|                    const std::string errorMessage("longseparator can not be set to empty");
 3476|       |#ifdef ARGS_NOEXCEPT
 3477|       |                    error = Error::Usage;
 3478|       |                    errorMsg = errorMessage;
 3479|       |#else
 3480|      0|                    throw UsageError(errorMessage);
 3481|      0|#endif
 3482|      0|                } else
 3483|  1.74k|                {
 3484|  1.74k|                    this->longseparator = longseparator_;
 3485|  1.74k|                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3485:54): [True: 1.74k, False: 0]
  ------------------
 3486|  1.74k|                }
 3487|  1.74k|            }
_ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  480|  3.47k|            Error(const std::string &problem) : std::runtime_error(problem) {}
_ZN4args14ArgumentParser10TerminatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3496|  1.74k|            { this->terminator = terminator_; }
_ZN4args14ArgumentParser22SetArgumentSeparationsEbbbb:
 3526|  1.74k|            {
 3527|  1.74k|                this->allowJoinedShortValue = allowJoinedShortValue_;
 3528|  1.74k|                this->allowJoinedLongValue = allowJoinedLongValue_;
 3529|  1.74k|                this->allowSeparateShortValue = allowSeparateShortValue_;
 3530|  1.74k|                this->allowSeparateLongValue = allowSeparateLongValue_;
 3531|       |
 3532|  1.74k|                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3532:50): [True: 1.74k, False: 0]
  ------------------
 3533|  1.74k|                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
  ------------------
  |  Branch (3533:51): [True: 1.74k, False: 0]
  ------------------
 3534|  1.74k|            }
_ZNK4args7Command7MatchedEv:
 2337|  18.1k|            { return Base::Matched(); }
_ZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2632|  3.62k|            {
 2633|  3.62k|                if (!Matched())
  ------------------
  |  Branch (2633:21): [True: 0, False: 3.62k]
  ------------------
 2634|      0|                {
 2635|      0|                    return;
 2636|      0|                }
 2637|       |
 2638|  3.62k|                auto onValidationError = [&]
 2639|  3.62k|                {
 2640|  3.62k|                    std::ostringstream problem;
 2641|  3.62k|                    problem << "Group validation failed somewhere!";
 2642|       |#ifdef ARGS_NOEXCEPT
 2643|       |                    error = Error::Validation;
 2644|       |                    errorMsg = problem.str();
 2645|       |#else
 2646|  3.62k|                    throw ValidationError(problem.str());
 2647|  3.62k|#endif
 2648|  3.62k|                };
 2649|       |
 2650|  3.62k|                for (Base *child: Children())
  ------------------
  |  Branch (2650:33): [True: 52.3k, False: 3.62k]
  ------------------
 2651|  52.3k|                {
 2652|  52.3k|                    if (child->IsGroup() && !child->Matched())
  ------------------
  |  Branch (2652:25): [True: 0, False: 52.3k]
  |  Branch (2652:45): [True: 0, False: 0]
  ------------------
 2653|      0|                    {
 2654|      0|                        onValidationError();
 2655|      0|                    }
 2656|       |
 2657|  52.3k|                    child->Validate(shortprefix, longprefix);
 2658|  52.3k|                }
 2659|       |
 2660|  3.62k|                if (subparser != nullptr)
  ------------------
  |  Branch (2660:21): [True: 0, False: 3.62k]
  ------------------
 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|  3.62k|                if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
  ------------------
  |  Branch (2669:21): [True: 1.74k, False: 1.88k]
  |  Branch (2669:51): [True: 1.74k, False: 0]
  |  Branch (2669:73): [True: 0, False: 1.74k]
  |  Branch (2669:96): [True: 0, False: 1.74k]
  ------------------
 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|  3.62k|            }
_ZN4args15ValidationErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  507|  1.88k|            ValidationError(const std::string &problem) : Error(problem) {}
_ZN4args7Command11GetCommandsEv:
 2535|  5.22k|            {
 2536|  5.22k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2536:21): [True: 0, False: 5.22k]
  ------------------
 2537|      0|                {
 2538|      0|                    return selectedCommand->GetCommands();
 2539|      0|                }
 2540|       |
 2541|  5.22k|                if (Matched())
  ------------------
  |  Branch (2541:21): [True: 5.22k, False: 0]
  ------------------
 2542|  5.22k|                {
 2543|  5.22k|                    return Group::GetCommands();
 2544|  5.22k|                }
 2545|       |
 2546|      0|                return { this };
 2547|  5.22k|            }
_ZNK4args4Base6IsFlagEv:
 1070|  5.22k|            {
 1071|  5.22k|                return false;
 1072|  5.22k|            }
_ZN4args7Command5MatchERKNS_10EitherFlagE:
 2356|  4.92k|            {
 2357|  4.92k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2357:21): [True: 0, False: 4.92k]
  ------------------
 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|  4.92k|                if (subparser != nullptr)
  ------------------
  |  Branch (2378:21): [True: 0, False: 4.92k]
  ------------------
 2379|      0|                {
 2380|      0|                    return subparser->Match(flag);
 2381|      0|                }
 2382|       |
 2383|  4.92k|                return Matched() ? Group::Match(flag) : nullptr;
  ------------------
  |  Branch (2383:24): [True: 4.92k, False: 0]
  ------------------
 2384|  4.92k|            }
_ZN4args7Command17GetNextPositionalEv:
 2420|  4.35k|            {
 2421|  4.35k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2421:21): [True: 0, False: 4.35k]
  ------------------
 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|  4.35k|                if (subparser != nullptr)
  ------------------
  |  Branch (2442:21): [True: 0, False: 4.35k]
  ------------------
 2443|      0|                {
 2444|      0|                    return subparser->GetNextPositional();
 2445|      0|                }
 2446|       |
 2447|  4.35k|                return Matched() ? Group::GetNextPositional() : nullptr;
  ------------------
  |  Branch (2447:24): [True: 4.35k, False: 0]
  ------------------
 2448|  4.35k|            }
_ZN4args14ArgumentParser5ResetEv:
 3664|  5.22k|            {
 3665|  5.22k|                Command::Reset();
 3666|  5.22k|                matched = true;
 3667|  5.22k|                readCompletion = false;
 3668|  5.22k|            }
_ZN4args10EitherFlagC2Ec:
  575|   159k|        EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
_ZN4args10EitherFlagC2EPKc:
  574|  20.8k|        EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args7MatcherC2ESt16initializer_listINS_10EitherFlagEE:
  680|  22.6k|                Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
_ZN4args10EitherFlag8GetShortESt16initializer_listIS0_E:
  595|  22.6k|        {
  596|  22.6k|            std::unordered_set<char>  shortFlags;
  597|  22.6k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (597:40): [True: 38.2k, False: 22.6k]
  ------------------
  598|  38.2k|            {
  599|  38.2k|                if (flag.isShort)
  ------------------
  |  Branch (599:21): [True: 17.4k, False: 20.8k]
  ------------------
  600|  17.4k|                {
  601|  17.4k|                    shortFlags.insert(flag.shortFlag);
  602|  17.4k|                }
  603|  38.2k|            }
  604|  22.6k|            return shortFlags;
  605|  22.6k|        }
_ZN4args10EitherFlag7GetLongESt16initializer_listIS0_E:
  580|  22.6k|        {
  581|  22.6k|            std::unordered_set<std::string>  longFlags;
  582|  22.6k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (582:40): [True: 38.2k, False: 22.6k]
  ------------------
  583|  38.2k|            {
  584|  38.2k|                if (!flag.isShort)
  ------------------
  |  Branch (584:21): [True: 20.8k, False: 17.4k]
  ------------------
  585|  20.8k|                {
  586|  20.8k|                    longFlags.insert(flag.longFlag);
  587|  20.8k|                }
  588|  38.2k|            }
  589|  22.6k|            return longFlags;
  590|  22.6k|        }
_ZN4args7MatcherC2INSt3__113unordered_setIcNS2_4hashIcEENS2_8equal_toIcEENS2_9allocatorIcEEEENS3_INS2_12basic_stringIcNS2_11char_traitsIcEES9_EENS4_ISE_EENS6_ISE_EENS8_ISE_EEEEEEOT_OT0_:
  664|  22.6k|                Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
  665|  22.6k|            {}
_ZN4args7MatcherC2INSt3__121__hash_const_iteratorIPNS2_11__hash_nodeIcPvEEEENS3_IPNS4_INS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES5_EEEEEET_SI_T0_SJ_:
  639|  22.6k|                shortFlags(shortFlagsStart, shortFlagsEnd),
  640|  22.6k|                longFlags(longFlagsStart, longFlagsEnd)
  641|  22.6k|            {
  642|  22.6k|                if (shortFlags.empty() && longFlags.empty())
  ------------------
  |  Branch (642:21): [True: 5.22k, False: 17.4k]
  |  Branch (642:43): [True: 0, False: 5.22k]
  ------------------
  643|      0|                {
  644|      0|#ifndef ARGS_NOEXCEPT
  645|      0|                    throw UsageError("empty Matcher");
  646|      0|#endif
  647|      0|                }
  648|  22.6k|            }
_ZN4args8HelpFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE:
 3816|  1.74k|            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:
 3781|  6.96k|            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
 3782|  6.96k|            {
 3783|  6.96k|                group_.Add(*this);
 3784|  6.96k|            }
_ZN4args8FlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE:
 1352|  22.6k|            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|  27.8k|            NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
_ZN4args9NamedBaseD2Ev:
 1186|  27.8k|            virtual ~NamedBase() {}
_ZN4args7MatcherC2EOS0_:
  682|  22.6k|            Matcher(Matcher &&other) noexcept : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
  683|  22.6k|            {}
_ZN4args5Group3AddERNS_4BaseE:
 1730|  27.8k|            {
 1731|  27.8k|                children.emplace_back(&child);
 1732|       |
 1733|  27.8k|                if(child.IsFlag()) {
  ------------------
  |  Branch (1733:20): [True: 22.6k, False: 5.22k]
  ------------------
 1734|  22.6k|#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|  22.6k|                    try
 1741|  22.6k|                    {
 1742|  22.6k|                        SignalDetectDuplicates();
 1743|  22.6k|                    }
 1744|  22.6k|                    catch (...)
 1745|  22.6k|                    {
 1746|      0|                        children.pop_back();
 1747|      0|                        throw;
 1748|      0|                    }
 1749|       |#else
 1750|       |                    SignalDetectDuplicates();
 1751|       |#endif
 1752|  22.6k|                }
 1753|  27.8k|            }
_ZN4args5Group22SignalDetectDuplicatesEv:
 1984|  22.6k|            {
 1985|  22.6k|                if(parent != nullptr) parent->SignalDetectDuplicates();
  ------------------
  |  Branch (1985:20): [True: 0, False: 22.6k]
  ------------------
 1986|  22.6k|                else DetectDuplicateFlags();
 1987|  22.6k|            }
_ZN4args5Group20DetectDuplicateFlagsEv:
 1994|  22.6k|            {
 1995|  22.6k|                std::unordered_set<char> usedShortFlags;
 1996|  22.6k|                std::unordered_set<std::string> usedLongFlags;
 1997|  22.6k|                DetectDuplicateFlags(usedShortFlags, usedLongFlags);
 1998|  22.6k|            }
_ZN4args5Group20DetectDuplicateFlagsERNSt3__113unordered_setIcNS1_4hashIcEENS1_8equal_toIcEENS1_9allocatorIcEEEERNS2_INS1_12basic_stringIcNS1_11char_traitsIcEES8_EENS3_ISE_EENS5_ISE_EENS7_ISE_EEEE:
 2003|  22.6k|            {
 2004|  22.6k|                for (Base *child: Children())
  ------------------
  |  Branch (2004:33): [True: 158k, False: 22.6k]
  ------------------
 2005|   158k|                {
 2006|   158k|                    if(auto flag = dynamic_cast<FlagBase*>(child))
  ------------------
  |  Branch (2006:29): [True: 158k, False: 0]
  ------------------
 2007|   158k|                    {
 2008|       |                        // Check for duplicate flags, setting a usage error on the
 2009|       |                        // flag if a duplicate is detected.
 2010|   158k|                        for(EitherFlag flagString: flag->GetMatcher().GetFlagStrings())
  ------------------
  |  Branch (2010:50): [True: 278k, False: 158k]
  ------------------
 2011|   278k|                        {
 2012|   278k|                            if(flagString.isShort)
  ------------------
  |  Branch (2012:32): [True: 139k, False: 139k]
  ------------------
 2013|   139k|                            {
 2014|   139k|                                if(usedShortFlags.count(flagString.shortFlag))
  ------------------
  |  Branch (2014:36): [True: 0, False: 139k]
  ------------------
 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|   139k|                                else
 2023|   139k|                                {
 2024|   139k|                                    usedShortFlags.insert(flagString.shortFlag);
 2025|   139k|                                }
 2026|   139k|                            }
 2027|   139k|                            else
 2028|   139k|                            {
 2029|   139k|                                if(usedLongFlags.count(flagString.longFlag))
  ------------------
  |  Branch (2029:36): [True: 0, False: 139k]
  ------------------
 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|   139k|                                else
 2038|   139k|                                {
 2039|   139k|                                    usedLongFlags.insert(flagString.longFlag);
 2040|   139k|                                }
 2041|   139k|                            }
 2042|   278k|                        }
 2043|   158k|                    }
 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|   158k|                }
 2057|  22.6k|            }
_ZNK4args8FlagBase10GetMatcherEv:
 1388|   158k|            {
 1389|   158k|                return matcher;
 1390|   158k|            }
_ZNK4args7Matcher14GetFlagStringsEv:
  711|   158k|            {
  712|   158k|                std::vector<EitherFlag> flagStrings;
  713|   158k|                flagStrings.reserve(shortFlags.size() + longFlags.size());
  714|   158k|                for (const char flag: shortFlags)
  ------------------
  |  Branch (714:37): [True: 139k, False: 158k]
  ------------------
  715|   139k|                {
  716|   139k|                    flagStrings.emplace_back(flag);
  717|   139k|                }
  718|   158k|                for (const std::string &flag: longFlags)
  ------------------
  |  Branch (718:45): [True: 139k, False: 158k]
  ------------------
  719|   139k|                {
  720|   139k|                    flagStrings.emplace_back(flag);
  721|   139k|                }
  722|   158k|                return flagStrings;
  723|   158k|            }
_ZN4args10EitherFlagC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  573|   143k|        EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  498|  1.55k|            ParseError(const std::string &problem) : Error(problem) {}
_ZN4args8FlagBaseD2Ev:
 1354|  22.6k|            virtual ~FlagBase() {}
_ZN4args4Flag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3805|  1.64k|            {
 3806|  1.64k|            }
_ZNK4args8FlagBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 1393|  47.1k|            {
 1394|  47.1k|                if (!Matched() && IsRequired())
  ------------------
  |  Branch (1394:21): [True: 45.2k, False: 1.83k]
  |  Branch (1394:35): [True: 1.88k, False: 43.4k]
  ------------------
 1395|  1.88k|                {
 1396|  1.88k|                        std::ostringstream problem;
 1397|  1.88k|                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
 1398|       |#ifdef ARGS_NOEXCEPT
 1399|       |                        error = Error::Required;
 1400|       |                        errorMsg = problem.str();
 1401|       |#else
 1402|  1.88k|                        throw RequiredError(problem.str());
 1403|  1.88k|#endif
 1404|  1.88k|                }
 1405|  47.1k|            }
_ZNK4args4Base10IsRequiredEv:
 1033|  50.5k|            {
 1034|  50.5k|                return (GetOptions() & Options::Required) != Options::None;
 1035|  50.5k|            }
_ZNK4args7Matcher12GetLongOrAnyEv:
  728|  1.88k|            {
  729|  1.88k|                if (!longFlags.empty())
  ------------------
  |  Branch (729:21): [True: 1.88k, False: 0]
  ------------------
  730|  1.88k|                {
  731|  1.88k|                    return *longFlags.begin();
  732|  1.88k|                }
  733|       |
  734|      0|                if (!shortFlags.empty())
  ------------------
  |  Branch (734:21): [True: 0, False: 0]
  ------------------
  735|      0|                {
  736|      0|                    return *shortFlags.begin();
  737|      0|                }
  738|       |
  739|       |                // should be unreachable
  740|      0|                return ' ';
  741|      0|            }
_ZNK4args10EitherFlag3strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  613|  1.88k|        {
  614|  1.88k|            return isShort ? shortPrefix + std::string(1, shortFlag) : longPrefix + longFlag;
  ------------------
  |  Branch (614:20): [True: 0, False: 1.88k]
  ------------------
  615|  1.88k|        }
_ZN4args13RequiredErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  516|  1.88k|            RequiredError(const std::string &problem) : ValidationError(problem) {}
_ZNK4args8FlagBase6IsFlagEv:
 1357|  22.6k|            {
 1358|  22.6k|                return true;
 1359|  22.6k|            }
_ZN4args8FlagBase5MatchERKNS_10EitherFlagE:
 1362|  44.0k|            {
 1363|  44.0k|                if (matcher.Match(flag))
  ------------------
  |  Branch (1363:21): [True: 4.63k, False: 39.4k]
  ------------------
 1364|  4.63k|                {
 1365|  4.63k|                    if ((GetOptions() & Options::Single) != Options::None && matched)
  ------------------
  |  Branch (1365:25): [True: 17, False: 4.61k]
  |  Branch (1365:78): [True: 2, False: 15]
  ------------------
 1366|      2|                    {
 1367|      2|                        std::ostringstream problem;
 1368|      2|                        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|      2|                        throw ExtraError(problem.str());
 1374|      2|#endif
 1375|      2|                    }
 1376|  4.62k|                    matched = true;
 1377|  4.62k|                    return this;
 1378|  4.63k|                }
 1379|  39.4k|                return nullptr;
 1380|  44.0k|            }
_ZNK4args7Matcher5MatchERKNS_10EitherFlagE:
  704|  44.0k|            {
  705|  44.0k|                return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
  ------------------
  |  Branch (705:24): [True: 14.5k, False: 29.5k]
  ------------------
  706|  44.0k|            }
_ZNK4args7Matcher5MatchEc:
  690|  14.5k|            {
  691|  14.5k|                return shortFlags.find(flag) != shortFlags.end();
  692|  14.5k|            }
_ZNK4args7Matcher5MatchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  697|  29.5k|            {
  698|  29.5k|                return longFlags.find(flag) != longFlags.end();
  699|  29.5k|            }
_ZNK4args10EitherFlag3strEv:
  608|      2|        {
  609|      2|            return isShort ? std::string(1, shortFlag) : longFlag;
  ------------------
  |  Branch (609:20): [True: 2, False: 0]
  ------------------
  610|      2|        }
_ZN4args10ExtraErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  534|      2|            ExtraError(const std::string &problem) : ParseError(problem) {}
_ZN4args5NargsC2Em:
  992|  4.22k|        Nargs(size_t num_) : min{num_}, max{num_}
  993|  4.22k|        {
  994|  4.22k|        }
_ZNK4args9NamedBase4NameEv:
 1234|     43|            {
 1235|     43|                return name;
 1236|     43|            }
_ZNK4args4Flag17NumberOfArgumentsEv:
 3800|  1.69k|            {
 3801|  1.69k|                return 0;
 3802|  1.69k|            }
_ZN4args8HelpFlag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3821|     43|            {
 3822|       |#ifdef ARGS_NOEXCEPT
 3823|       |                    error = Error::Help;
 3824|       |                    errorMsg = Name();
 3825|       |#else
 3826|     43|                    throw Help(Name());
 3827|     43|#endif
 3828|     43|            }
_ZN4args4HelpC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  543|     43|            Help(const std::string &flag) : Error(flag) {}
_ZN4args7MatcherD2Ev:
  685|  45.2k|            ~Matcher() {}
_ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEb:
 3786|  1.74k|            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 (3786:186): [True: 0, False: 1.74k]
  ------------------
 3787|  1.74k|            {
 3788|  1.74k|            }
_ZN4args11CounterFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEiNS_7OptionsE:
 3848|  1.74k|                Flag(group_, name_, help_, std::move(matcher_), options_), startcount(startcount_), count(startcount_) {}
_ZN4args11CounterFlag5MatchERKNS_10EitherFlagE:
 3853|  4.80k|            {
 3854|  4.80k|                auto me = FlagBase::Match(arg);
 3855|  4.80k|                if (me)
  ------------------
  |  Branch (3855:21): [True: 1.58k, False: 3.22k]
  ------------------
 3856|  1.58k|                {
 3857|       |#ifdef ARGS_NOEXCEPT
 3858|       |                    // Suppress increment when FlagBase::Match recorded an
 3859|       |                    // error on this same call (e.g. Options::Single violated).
 3860|       |                    // In non-noexcept mode that path would have thrown before
 3861|       |                    // reaching here and the count would not have advanced.
 3862|       |                    if (GetError() != Error::None)
 3863|       |                    {
 3864|       |                        return me;
 3865|       |                    }
 3866|       |#endif
 3867|  1.58k|                    ++count;
 3868|  1.58k|                }
 3869|  4.80k|                return me;
 3870|  4.80k|            }
_ZN4args11CounterFlag5ResetEv:
 3888|  5.22k|            {
 3889|  5.22k|                FlagBase::Reset();
 3890|  5.22k|                count = startcount;
 3891|  5.22k|            }
_ZN4args5NargsC2Emm:
  982|  1.89k|        Nargs(size_t min_, size_t max_) : min{min_}, max{max_}
  983|  1.89k|        {
  984|  1.89k|#ifndef ARGS_NOEXCEPT
  985|  1.89k|            if (max < min)
  ------------------
  |  Branch (985:17): [True: 0, False: 1.89k]
  ------------------
  986|      0|            {
  987|      0|                throw UsageError("Nargs: max < min");
  988|      0|            }
  989|  1.89k|#endif
  990|  1.89k|        }
_ZN4args11CounterFlag3GetEv:
 3875|  1.74k|            {
 3876|  1.74k|                return count;
 3877|  1.74k|            }
_ZNK4args4BasecvbEv:
 1047|  19.1k|            {
 1048|  19.1k|                return Matched();
 1049|  19.1k|            }
_ZN4args14ArgumentParser9ParseArgsINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEEDTclsr3stdE5beginfp_EERKT_:
 3698|  5.22k|            {
 3699|  5.22k|                return ParseArgs(std::begin(args), std::end(args));
 3700|  5.22k|            }
_ZN4args14ArgumentParser9ParseArgsINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SD_SD_:
 3678|  5.22k|            {
 3679|       |                // Reset all Matched statuses and errors
 3680|  5.22k|                Reset();
 3681|       |#ifdef ARGS_NOEXCEPT
 3682|       |                error = GetError();
 3683|       |                if (error != Error::None)
 3684|       |                {
 3685|       |                    return end;
 3686|       |                }
 3687|       |#endif
 3688|  5.22k|                return Parse(begin, end);
 3689|  5.22k|            }
_ZN4args14ArgumentParser5ParseINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SD_SD_:
 3198|  5.22k|            {
 3199|  5.22k|                bool terminated = false;
 3200|  5.22k|                std::vector<Command *> commands = GetCommands();
 3201|       |
 3202|       |                // Check all arg chunks
 3203|  13.1k|                for (auto it = begin; it != end; ++it)
  ------------------
  |  Branch (3203:39): [True: 7.88k, False: 5.22k]
  ------------------
 3204|  7.88k|                {
 3205|  7.88k|                    if (Complete(it, end, terminated))
  ------------------
  |  Branch (3205:25): [True: 0, False: 7.88k]
  ------------------
 3206|      0|                    {
 3207|      0|                        return end;
 3208|      0|                    }
 3209|       |
 3210|  7.88k|                    const auto &chunk = *it;
 3211|       |
 3212|  7.88k|                    if (!terminated && chunk == terminator)
  ------------------
  |  Branch (3212:25): [True: 7.85k, False: 29]
  |  Branch (3212:40): [True: 8, False: 7.84k]
  ------------------
 3213|      8|                    {
 3214|      8|                        terminated = true;
 3215|  7.87k|                    } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
  ------------------
  |  Branch (3215:32): [True: 7.84k, False: 29]
  |  Branch (3215:47): [True: 2.41k, False: 5.42k]
  ------------------
 3216|  2.41k|                    {
 3217|  2.41k|                        if (!ParseLong(it, end))
  ------------------
  |  Branch (3217:29): [True: 0, False: 2.41k]
  ------------------
 3218|      0|                        {
 3219|      0|                            return it;
 3220|      0|                        }
 3221|  5.45k|                    } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
  ------------------
  |  Branch (3221:32): [True: 5.42k, False: 29]
  |  Branch (3221:47): [True: 1.10k, False: 4.32k]
  ------------------
 3222|  1.10k|                    {
 3223|  1.10k|                        if (!ParseShort(it, end))
  ------------------
  |  Branch (3223:29): [True: 0, False: 1.10k]
  ------------------
 3224|      0|                        {
 3225|      0|                            return it;
 3226|      0|                        }
 3227|  4.35k|                    } else if (!terminated && !commands.empty())
  ------------------
  |  Branch (3227:32): [True: 4.32k, False: 29]
  |  Branch (3227:47): [True: 0, False: 4.32k]
  ------------------
 3228|      0|                    {
 3229|      0|                        auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
 3230|      0|                        if (itCommand == commands.end())
  ------------------
  |  Branch (3230:29): [True: 0, False: 0]
  ------------------
 3231|      0|                        {
 3232|      0|                            const std::string errorMessage("Unknown command: " + chunk);
 3233|      0|#ifndef ARGS_NOEXCEPT
 3234|      0|                            throw ParseError(errorMessage);
 3235|       |#else
 3236|       |                            error = Error::Parse;
 3237|       |                            errorMsg = errorMessage;
 3238|       |                            return it;
 3239|       |#endif
 3240|      0|                        }
 3241|       |
 3242|      0|                        SelectCommand(*itCommand);
 3243|       |
 3244|      0|                        if (const auto &coroutine = GetCoroutine())
  ------------------
  |  Branch (3244:41): [True: 0, False: 0]
  ------------------
 3245|      0|                        {
 3246|      0|                            ++it;
 3247|      0|                            RaiiSubparser coro(*this, std::vector<std::string>(it, end));
 3248|      0|                            coroutine(coro.Parser());
 3249|       |#ifdef ARGS_NOEXCEPT
 3250|       |                            error = GetError();
 3251|       |                            if (error != Error::None)
 3252|       |                            {
 3253|       |                                return end;
 3254|       |                            }
 3255|       |
 3256|       |                            if (!coro.Parser().IsParsed())
 3257|       |                            {
 3258|       |                                error = Error::Usage;
 3259|       |                                return end;
 3260|       |                            }
 3261|       |#else
 3262|      0|                            if (!coro.Parser().IsParsed())
  ------------------
  |  Branch (3262:33): [True: 0, False: 0]
  ------------------
 3263|      0|                            {
 3264|      0|                                throw UsageError("Subparser::Parse was not called");
 3265|      0|                            }
 3266|      0|#endif
 3267|       |
 3268|      0|                            break;
 3269|      0|                        }
 3270|       |
 3271|      0|                        commands = GetCommands();
 3272|      0|                    } else
 3273|  4.35k|                    {
 3274|  4.35k|                        auto pos = GetNextPositional();
 3275|  4.35k|                        if (pos)
  ------------------
  |  Branch (3275:29): [True: 4.35k, False: 0]
  ------------------
 3276|  4.35k|                        {
 3277|  4.35k|                            pos->ParseValue(chunk);
 3278|       |#ifdef ARGS_NOEXCEPT
 3279|       |                            if (pos->GetError() != Error::None)
 3280|       |                            {
 3281|       |                                return it;
 3282|       |                            }
 3283|       |#endif
 3284|       |
 3285|  4.35k|                            if (pos->KickOut())
  ------------------
  |  Branch (3285:33): [True: 0, False: 4.35k]
  ------------------
 3286|      0|                            {
 3287|      0|                                return ++it;
 3288|      0|                            }
 3289|  4.35k|                        } else
 3290|      0|                        {
 3291|      0|                            const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
 3292|      0|#ifndef ARGS_NOEXCEPT
 3293|      0|                            throw ParseError(errorMessage);
 3294|       |#else
 3295|       |                            error = Error::Parse;
 3296|       |                            errorMsg = errorMessage;
 3297|       |                            return it;
 3298|       |#endif
 3299|      0|                        }
 3300|  4.35k|                    }
 3301|       |
 3302|  7.88k|                    if (!readCompletion && completion != nullptr && completion->Matched())
  ------------------
  |  Branch (3302:25): [True: 6.28k, False: 1.59k]
  |  Branch (3302:44): [True: 0, False: 6.28k]
  |  Branch (3302:69): [True: 0, False: 0]
  ------------------
 3303|      0|                    {
 3304|       |#ifdef ARGS_NOEXCEPT
 3305|       |                        if (completion->GetError() != Error::None)
 3306|       |                        {
 3307|       |                            error = completion->GetError();
 3308|       |                            if (errorMsg.empty())
 3309|       |                            {
 3310|       |                                errorMsg = completion->GetErrorMsg();
 3311|       |                            }
 3312|       |                            return it;
 3313|       |                        }
 3314|       |
 3315|       |                        error = Error::Completion;
 3316|       |#endif
 3317|      0|                        readCompletion = true;
 3318|      0|                        ++it;
 3319|      0|                        const auto argsLeft = static_cast<size_t>(std::distance(it, end));
 3320|      0|                        if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
  ------------------
  |  Branch (3320:29): [True: 0, False: 0]
  |  Branch (3320:55): [True: 0, False: 0]
  |  Branch (3320:72): [True: 0, False: 0]
  ------------------
 3321|      0|                        {
 3322|      0|#ifndef ARGS_NOEXCEPT
 3323|      0|                            throw Completion("");
 3324|       |#else
 3325|       |                            return end;
 3326|       |#endif
 3327|      0|                        }
 3328|       |
 3329|      0|                        ++it;
 3330|      0|                        std::vector<std::string> curArgs;
 3331|      0|                        curArgs.reserve(completion->cword);
 3332|      0|                        auto curIt = it;
 3333|      0|                        for (size_t idx = 0; idx < completion->cword && curIt != end; ++idx, ++curIt)
  ------------------
  |  Branch (3333:46): [True: 0, False: 0]
  |  Branch (3333:73): [True: 0, False: 0]
  ------------------
 3334|      0|                        {
 3335|      0|                            curArgs.push_back(*curIt);
 3336|      0|                        }
 3337|       |
 3338|      0|                        if (completion->syntax == "bash")
  ------------------
  |  Branch (3338:29): [True: 0, False: 0]
  ------------------
 3339|      0|                        {
 3340|       |                            // bash tokenizes --flag=value as --flag=value
 3341|       |                            // Security fix: Use size_t arithmetic throughout to avoid conversion issues
 3342|      0|                            for (size_t idx = 0; idx < curArgs.size(); )
  ------------------
  |  Branch (3342:50): [True: 0, False: 0]
  ------------------
 3343|      0|                            {
 3344|      0|                                if (idx > 0 && curArgs[idx] == "=")
  ------------------
  |  Branch (3344:37): [True: 0, False: 0]
  |  Branch (3344:48): [True: 0, False: 0]
  ------------------
 3345|      0|                                {
 3346|      0|                                    size_t prev_idx = idx - 1;  // Safe since we checked idx > 0
 3347|      0|                                    curArgs[prev_idx] += "=";
 3348|      0|                                    size_t next_idx = 0;
 3349|      0|                                    if (SafeAdd<size_t>(idx, static_cast<size_t>(1), next_idx) && next_idx < curArgs.size())
  ------------------
  |  Branch (3349:41): [True: 0, False: 0]
  |  Branch (3349:99): [True: 0, False: 0]
  ------------------
 3350|      0|                                    {
 3351|      0|                                        curArgs[prev_idx] += curArgs[next_idx];
 3352|       |                                        // Erase the '=' token and the following value token.
 3353|      0|                                        size_t erase_end = 0;
 3354|      0|                                        if (SafeAdd<size_t>(next_idx, static_cast<size_t>(1), erase_end))
  ------------------
  |  Branch (3354:45): [True: 0, False: 0]
  ------------------
 3355|      0|                                        {
 3356|      0|                                            typedef std::vector<std::string>::difference_type diff_t;
 3357|      0|                                            curArgs.erase(curArgs.begin() + static_cast<diff_t>(idx),
 3358|      0|                                                         curArgs.begin() + static_cast<diff_t>(erase_end));
 3359|      0|                                        }
 3360|      0|                                    } else
 3361|      0|                                    {
 3362|       |                                        // Safe erase of single '=' token at the end
 3363|      0|                                        typedef std::vector<std::string>::difference_type diff_t;
 3364|      0|                                        curArgs.erase(curArgs.begin() + static_cast<diff_t>(idx));
 3365|      0|                                    }
 3366|       |                                    // Do not increment idx - next element slides into current position
 3367|      0|                                } else
 3368|      0|                                {
 3369|      0|                                    ++idx;
 3370|      0|                                }
 3371|      0|                            }
 3372|       |
 3373|      0|                        }
 3374|      0|#ifndef ARGS_NOEXCEPT
 3375|      0|                        try
 3376|      0|                        {
 3377|      0|                            Parse(curArgs.begin(), curArgs.end());
 3378|      0|                            throw Completion("");
 3379|      0|                        }
 3380|      0|                        catch (Completion &)
 3381|      0|                        {
 3382|      0|                            throw;
 3383|      0|                        }
 3384|      0|                        catch (args::Error&)
 3385|      0|                        {
 3386|      0|                            throw Completion("");
 3387|      0|                        }
 3388|       |#else
 3389|       |                        // Discard the nested Parse's return value: it points
 3390|       |                        // into the local curArgs vector, which is destroyed
 3391|       |                        // when this function returns, leaving the caller with
 3392|       |                        // a dangling iterator that would be compared against
 3393|       |                        // the outer `end` in ParseCLI. Return the outer
 3394|       |                        // `end` instead so the iterator stays in the caller's
 3395|       |                        // container.
 3396|       |                        Parse(curArgs.begin(), curArgs.end());
 3397|       |                        error = Error::Completion;
 3398|       |                        errorMsg.clear();
 3399|       |                        return end;
 3400|       |#endif
 3401|      0|                    }
 3402|  7.88k|                }
 3403|       |
 3404|  5.22k|                Validate(shortprefix, longprefix);
 3405|  5.22k|                return end;
 3406|  5.22k|            }
_ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbT_SD_b:
 3070|  7.88k|            {
 3071|  7.88k|                auto nextIt = it;
 3072|  7.88k|                if (!readCompletion || (++nextIt != end))
  ------------------
  |  Branch (3072:21): [True: 7.88k, False: 0]
  |  Branch (3072:40): [True: 0, False: 0]
  ------------------
 3073|  7.88k|                {
 3074|  7.88k|                    return false;
 3075|  7.88k|                }
 3076|       |
 3077|      0|                const auto &chunk = *it;
 3078|      0|                auto pos = GetNextPositional();
 3079|      0|                std::vector<Command *> commands = GetCommands();
 3080|      0|                const auto optionType = ParseOption(chunk, true);
 3081|       |
 3082|       |                // Once the terminator has been seen the parser treats every
 3083|       |                // following chunk as positional, so only positional choices are
 3084|       |                // valid completions here. Suggesting flags or commands past the
 3085|       |                // terminator offers candidates the parser would then reject.
 3086|      0|                if (!terminated && !commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
  ------------------
  |  Branch (3086:21): [True: 0, False: 0]
  |  Branch (3086:36): [True: 0, False: 0]
  |  Branch (3086:58): [True: 0, False: 0]
  |  Branch (3086:75): [True: 0, False: 0]
  ------------------
 3087|      0|                {
 3088|      0|                    for (auto &cmd : commands)
  ------------------
  |  Branch (3088:36): [True: 0, False: 0]
  ------------------
 3089|      0|                    {
 3090|      0|                        if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3090:29): [True: 0, False: 0]
  ------------------
 3091|      0|                        {
 3092|      0|                            AddCompletionReply(chunk, cmd->Name());
 3093|      0|                        }
 3094|      0|                    }
 3095|      0|                } else
 3096|      0|                {
 3097|      0|                    bool hasPositionalCompletion = true;
 3098|       |
 3099|      0|                    if (!terminated && !commands.empty())
  ------------------
  |  Branch (3099:25): [True: 0, False: 0]
  |  Branch (3099:40): [True: 0, False: 0]
  ------------------
 3100|      0|                    {
 3101|      0|                        for (auto &cmd : commands)
  ------------------
  |  Branch (3101:40): [True: 0, False: 0]
  ------------------
 3102|      0|                        {
 3103|      0|                            if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3103:33): [True: 0, False: 0]
  ------------------
 3104|      0|                            {
 3105|      0|                                AddCompletionReply(chunk, cmd->Name());
 3106|      0|                            }
 3107|      0|                        }
 3108|      0|                    } else if (pos)
  ------------------
  |  Branch (3108:32): [True: 0, False: 0]
  ------------------
 3109|      0|                    {
 3110|      0|                        if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (3110:29): [True: 0, False: 0]
  ------------------
 3111|      0|                        {
 3112|      0|                            auto choices = pos->HelpChoices(helpParams);
 3113|      0|                            hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
  ------------------
  |  Branch (3113:55): [True: 0, False: 0]
  |  Branch (3113:75): [True: 0, False: 0]
  ------------------
 3114|      0|                            for (auto &choice : choices)
  ------------------
  |  Branch (3114:47): [True: 0, False: 0]
  ------------------
 3115|      0|                            {
 3116|      0|                                AddCompletionReply(chunk, choice);
 3117|      0|                            }
 3118|      0|                        }
 3119|      0|                    }
 3120|       |
 3121|      0|                    if (!terminated && hasPositionalCompletion)
  ------------------
  |  Branch (3121:25): [True: 0, False: 0]
  |  Branch (3121:40): [True: 0, False: 0]
  ------------------
 3122|      0|                    {
 3123|      0|                        auto flags = GetAllFlags();
 3124|      0|                        for (auto flag : flags)
  ------------------
  |  Branch (3124:40): [True: 0, False: 0]
  ------------------
 3125|      0|                        {
 3126|      0|                            if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
  ------------------
  |  Branch (3126:33): [True: 0, False: 0]
  ------------------
 3127|      0|                            {
 3128|      0|                                continue;
 3129|      0|                            }
 3130|       |
 3131|      0|                            auto &matcher = flag->GetMatcher();
 3132|      0|                            if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
  ------------------
  |  Branch (3132:33): [True: 0, False: 0]
  ------------------
 3133|      0|                            {
 3134|      0|                                for (auto &flagName : matcher.GetFlagStrings())
  ------------------
  |  Branch (3134:53): [True: 0, False: 0]
  ------------------
 3135|      0|                                {
 3136|      0|                                    if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
  ------------------
  |  Branch (3136:41): [True: 0, False: 0]
  ------------------
 3137|      0|                                    {
 3138|      0|                                        break;
 3139|      0|                                    }
 3140|      0|                                }
 3141|      0|                            }
 3142|      0|                        }
 3143|       |
 3144|      0|                        if (optionType == OptionType::LongFlag && allowJoinedLongValue)
  ------------------
  |  Branch (3144:29): [True: 0, False: 0]
  |  Branch (3144:67): [True: 0, False: 0]
  ------------------
 3145|      0|                        {
 3146|      0|                            const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
  ------------------
  |  Branch (3146:52): [True: 0, False: 0]
  ------------------
 3147|       |                            // Only attempt joined-value completion when the
 3148|       |                            // separator lies at or past the long prefix, so
 3149|       |                            // there is a (possibly empty) flag name between
 3150|       |                            // them. With a custom longseparator that overlaps
 3151|       |                            // the prefix (e.g. LongSeparator("-") under the
 3152|       |                            // default "--" prefix), an attacker-controlled
 3153|       |                            // completion word like "--x" puts the separator
 3154|       |                            // inside the prefix, making `arg` shorter than
 3155|       |                            // longprefix. arg.substr(longprefix.size()) would
 3156|       |                            // then throw std::out_of_range, which escapes the
 3157|       |                            // parser as a non-args exception (bypassing the
 3158|       |                            // documented catch(args::Error) idiom) and is
 3159|       |                            // thrown even under ARGS_NOEXCEPT.
 3160|      0|                            if (separator != chunk.npos && separator >= longprefix.size())
  ------------------
  |  Branch (3160:33): [True: 0, False: 0]
  |  Branch (3160:60): [True: 0, False: 0]
  ------------------
 3161|      0|                            {
 3162|      0|                                std::string arg(chunk, 0, separator);
 3163|      0|                                if (auto flag = this->Match(arg.substr(longprefix.size())))
  ------------------
  |  Branch (3163:42): [True: 0, False: 0]
  ------------------
 3164|      0|                                {
 3165|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (3165:55): [True: 0, False: 0]
  ------------------
 3166|      0|                                    {
 3167|      0|                                        AddCompletionReply(chunk, arg + longseparator + choice);
 3168|      0|                                    }
 3169|      0|                                }
 3170|      0|                            }
 3171|      0|                        } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
  ------------------
  |  Branch (3171:36): [True: 0, False: 0]
  |  Branch (3171:75): [True: 0, False: 0]
  ------------------
 3172|      0|                        {
 3173|      0|                            if (chunk.size() > shortprefix.size() + 1)
  ------------------
  |  Branch (3173:33): [True: 0, False: 0]
  ------------------
 3174|      0|                            {
 3175|      0|                                auto arg = chunk.at(shortprefix.size());
 3176|       |                                //TODO: support -abcVALUE where a and b take no value
 3177|      0|                                if (auto flag = this->Match(arg))
  ------------------
  |  Branch (3177:42): [True: 0, False: 0]
  ------------------
 3178|      0|                                {
 3179|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (3179:55): [True: 0, False: 0]
  ------------------
 3180|      0|                                    {
 3181|      0|                                        AddCompletionReply(chunk, shortprefix + arg + choice);
 3182|      0|                                    }
 3183|      0|                                }
 3184|      0|                            }
 3185|      0|                        }
 3186|      0|                    }
 3187|      0|                }
 3188|       |
 3189|      0|#ifndef ARGS_NOEXCEPT
 3190|      0|                throw Completion(completion->Get());
 3191|       |#else
 3192|       |                return true;
 3193|       |#endif
 3194|  7.88k|            }
_ZN4args14ArgumentParser11ParseOptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 2751|  13.6k|            {
 2752|  13.6k|                const bool matchesLong = s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length());
  ------------------
  |  Branch (2752:42): [True: 2.43k, False: 11.2k]
  |  Branch (2752:70): [True: 0, False: 2.43k]
  |  Branch (2752:84): [True: 2.43k, False: 0]
  ------------------
 2753|  13.6k|                const bool matchesShort = s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length());
  ------------------
  |  Branch (2753:43): [True: 4.88k, False: 8.78k]
  |  Branch (2753:72): [True: 0, False: 4.88k]
  |  Branch (2753:86): [True: 4.85k, False: 28]
  ------------------
 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|  13.6k|                if (matchesLong && matchesShort)
  ------------------
  |  Branch (2761:21): [True: 2.43k, False: 11.2k]
  |  Branch (2761:36): [True: 2.43k, False: 0]
  ------------------
 2762|  2.43k|                {
 2763|  2.43k|                    return longprefix.length() >= shortprefix.length() ? OptionType::LongFlag : OptionType::ShortFlag;
  ------------------
  |  Branch (2763:28): [True: 2.43k, False: 0]
  ------------------
 2764|  2.43k|                }
 2765|       |
 2766|  11.2k|                if (matchesLong)
  ------------------
  |  Branch (2766:21): [True: 0, False: 11.2k]
  ------------------
 2767|      0|                {
 2768|      0|                    return OptionType::LongFlag;
 2769|      0|                }
 2770|       |
 2771|  11.2k|                if (matchesShort)
  ------------------
  |  Branch (2771:21): [True: 2.42k, False: 8.81k]
  ------------------
 2772|  2.42k|                {
 2773|  2.42k|                    return OptionType::ShortFlag;
 2774|  2.42k|                }
 2775|       |
 2776|  8.81k|                return OptionType::Positional;
 2777|  11.2k|            }
_ZN4args14ArgumentParser9ParseLongINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SD_:
 2898|  2.41k|            {
 2899|  2.41k|                const auto &chunk = *it;
 2900|  2.41k|                const auto argchunk = chunk.substr(longprefix.size());
 2901|       |                // Try to separate it, in case of a separator:
 2902|  2.41k|                const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
  ------------------
  |  Branch (2902:40): [True: 0, False: 2.41k]
  ------------------
 2903|       |                // If the separator is in the argument, separate it.
 2904|  2.41k|                const auto arg = (separator != argchunk.npos ?
  ------------------
  |  Branch (2904:35): [True: 466, False: 1.95k]
  ------------------
 2905|    466|                    std::string(argchunk, 0, separator)
 2906|  2.41k|                    : argchunk);
 2907|  2.41k|                const auto joined = (separator != argchunk.npos ?
  ------------------
  |  Branch (2907:38): [True: 466, False: 1.95k]
  ------------------
 2908|    466|                    argchunk.substr(separator + longseparator.size())
 2909|  2.41k|                    : std::string());
 2910|       |
 2911|  2.41k|                if (auto flag = Match(arg))
  ------------------
  |  Branch (2911:26): [True: 2.27k, False: 140]
  ------------------
 2912|  2.27k|                {
 2913|       |#ifdef ARGS_NOEXCEPT
 2914|       |                    // Match() may set the flag's error (e.g. Error::Extra when
 2915|       |                    // Options::Single is violated). In non-noexcept mode that
 2916|       |                    // path throws and parsing stops before the value is read;
 2917|       |                    // in noexcept mode we must mirror that and skip the value
 2918|       |                    // parsing so the previously-stored value is preserved.
 2919|       |                    if (flag->GetError() != Error::None)
 2920|       |                    {
 2921|       |                        return false;
 2922|       |                    }
 2923|       |#endif
 2924|  2.27k|                    std::vector<std::string> values;
 2925|  2.27k|                    const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
 2926|  2.27k|                                                                     separator != argchunk.npos, joined, false, values);
 2927|  2.27k|                    if (!errorMessage.empty())
  ------------------
  |  Branch (2927:25): [True: 4, False: 2.27k]
  ------------------
 2928|      4|                    {
 2929|      4|#ifndef ARGS_NOEXCEPT
 2930|      4|                        throw ParseError(errorMessage);
 2931|       |#else
 2932|       |                        error = Error::Parse;
 2933|       |                        errorMsg = errorMessage;
 2934|       |                        return false;
 2935|       |#endif
 2936|      4|                    }
 2937|       |
 2938|  2.27k|                    if (!readCompletion)
  ------------------
  |  Branch (2938:25): [True: 2.27k, False: 0]
  ------------------
 2939|  2.27k|                    {
 2940|  2.27k|                        flag->ParseValue(values);
 2941|       |#ifdef ARGS_NOEXCEPT
 2942|       |                        // Non-noexcept ParseValue paths throw on Help, reader
 2943|       |                        // failure, or Map miss, which halts parsing. Mirror
 2944|       |                        // that here so a later parser-level error (e.g. an
 2945|       |                        // unknown flag) cannot shadow the flag's error in
 2946|       |                        // ArgumentParser::GetError().
 2947|       |                        if (flag->GetError() != Error::None)
 2948|       |                        {
 2949|       |                            return false;
 2950|       |                        }
 2951|       |#endif
 2952|  2.27k|                    }
 2953|       |
 2954|  2.27k|                    if (flag->KickOut())
  ------------------
  |  Branch (2954:25): [True: 0, False: 2.27k]
  ------------------
 2955|      0|                    {
 2956|      0|                        ++it;
 2957|      0|                        return false;
 2958|      0|                    }
 2959|  2.27k|                } else
 2960|    140|                {
 2961|    140|                    const std::string errorMessage("Flag could not be matched: " + arg);
 2962|    140|#ifndef ARGS_NOEXCEPT
 2963|    140|                    throw ParseError(errorMessage);
 2964|       |#else
 2965|       |                    error = Error::Parse;
 2966|       |                    errorMsg = errorMessage;
 2967|       |                    return false;
 2968|       |#endif
 2969|    140|                }
 2970|       |
 2971|  2.27k|                return true;
 2972|  2.41k|            }
_ZN4args14ArgumentParser15ParseArgsValuesINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_RNS_8FlagBaseERSA_RT_SG_bbbSF_bRNS2_6vectorIS9_NS7_IS9_EEEE:
 2815|  4.62k|            {
 2816|  4.62k|                values.clear();
 2817|       |
 2818|  4.62k|                Nargs nargs = flag.NumberOfArguments();
 2819|       |
 2820|  4.62k|                if (hasJoined && !allowJoined && (nargs.min != 0 || !canDiscardJoined))
  ------------------
  |  Branch (2820:21): [True: 2.01k, False: 2.61k]
  |  Branch (2820:34): [True: 0, False: 2.01k]
  |  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|  4.62k|                if (hasJoined)
  ------------------
  |  Branch (2825:21): [True: 2.01k, False: 2.61k]
  ------------------
 2826|  2.01k|                {
 2827|  2.01k|                    if (!canDiscardJoined || (allowJoined && nargs.max != 0))
  ------------------
  |  Branch (2827:25): [True: 455, False: 1.55k]
  |  Branch (2827:47): [True: 1.55k, False: 0]
  |  Branch (2827:62): [True: 159, False: 1.39k]
  ------------------
 2828|    614|                    {
 2829|    614|                        values.push_back(joinedArg);
 2830|    614|                    }
 2831|  2.61k|                } else if (!allowSeparate)
  ------------------
  |  Branch (2831:28): [True: 0, False: 2.61k]
  ------------------
 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|  2.61k|                } else if (allowSeparate && (!hasJoined || !values.empty())) {
  ------------------
  |  Branch (2837:28): [True: 2.61k, False: 0]
  |  Branch (2837:46): [True: 2.61k, False: 0]
  |  Branch (2837:60): [True: 0, False: 0]
  ------------------
 2838|       |                    // Only gather separate values when they are allowed. A joined
 2839|       |                    // value that was discarded rather than taken (short chunks such
 2840|       |                    // as -nf when joined short values are off) means this flag isn't
 2841|       |                    // taking an argument here, so the rest of the chunk is flags.
 2842|  2.61k|                    auto valueIt = it;
 2843|  2.61k|                    ++valueIt;
 2844|       |
 2845|  4.78k|                    while (valueIt != end &&
  ------------------
  |  Branch (2845:28): [True: 4.73k, False: 52]
  ------------------
 2846|  4.73k|                           *valueIt != terminator &&
  ------------------
  |  Branch (2846:28): [True: 4.73k, False: 1]
  ------------------
 2847|  4.73k|                           values.size() < nargs.max &&
  ------------------
  |  Branch (2847:28): [True: 2.39k, False: 2.33k]
  ------------------
 2848|  2.39k|                           (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional))
  ------------------
  |  Branch (2848:29): [True: 1.99k, False: 398]
  |  Branch (2848:58): [True: 172, False: 226]
  ------------------
 2849|  2.16k|                    {
 2850|  2.16k|                        if (Complete(flag, valueIt, end))
  ------------------
  |  Branch (2850:29): [True: 0, False: 2.16k]
  ------------------
 2851|      0|                        {
 2852|       |                            // Park `it` on the completion position rather than
 2853|       |                            // `end`. In ARGS_NOEXCEPT mode Complete returns
 2854|       |                            // true (no throw), so the caller's for-loop will
 2855|       |                            // run its ++it after we return; advancing an
 2856|       |                            // already-end iterator is undefined behavior and
 2857|       |                            // causes a subsequent out-of-bounds read of the
 2858|       |                            // arg vector. Since Complete only fires when
 2859|       |                            // ++nextIt == end, valueIt is the last element,
 2860|       |                            // and ++(it=valueIt) safely lands on end.
 2861|      0|                            it = valueIt;
 2862|      0|                            return "";
 2863|      0|                        }
 2864|       |
 2865|  2.16k|                        values.push_back(*valueIt);
 2866|  2.16k|                        ++it;
 2867|  2.16k|                        ++valueIt;
 2868|  2.16k|                    }
 2869|  2.61k|                }
 2870|       |
 2871|  4.62k|                if (values.size() > nargs.max)
  ------------------
  |  Branch (2871:21): [True: 2, False: 4.62k]
  ------------------
 2872|      2|                {
 2873|      2|                    return "Passed an argument into a non-argument flag: " + arg;
 2874|  4.62k|                } else if (values.size() < nargs.min)
  ------------------
  |  Branch (2874:28): [True: 4, False: 4.62k]
  ------------------
 2875|      4|                {
 2876|      4|                    if (nargs.min == 1 && nargs.max == 1)
  ------------------
  |  Branch (2876:25): [True: 4, False: 0]
  |  Branch (2876:43): [True: 4, False: 0]
  ------------------
 2877|      4|                    {
 2878|      4|                        return "Flag '" + arg + "' requires an argument but received none";
 2879|      4|                    } else if (nargs.min == 1)
  ------------------
  |  Branch (2879:32): [True: 0, False: 0]
  ------------------
 2880|      0|                    {
 2881|      0|                        return "Flag '" + arg + "' requires at least one argument but received none";
 2882|      0|                    } else if (nargs.min != nargs.max)
  ------------------
  |  Branch (2882:32): [True: 0, False: 0]
  ------------------
 2883|      0|                    {
 2884|      0|                        return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
 2885|      0|                               " arguments but received " + std::to_string(values.size());
 2886|      0|                    } else
 2887|      0|                    {
 2888|      0|                        return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
 2889|      0|                               " arguments but received " + std::to_string(values.size());
 2890|      0|                    }
 2891|      4|                }
 2892|       |
 2893|  4.62k|                return {};
 2894|  4.62k|            }
_ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRNS_8FlagBaseET_SF_:
 2781|  2.16k|            {
 2782|  2.16k|                auto nextIt = it;
 2783|  2.16k|                if (!readCompletion || (++nextIt != end))
  ------------------
  |  Branch (2783:21): [True: 2.16k, False: 0]
  |  Branch (2783:40): [True: 0, False: 0]
  ------------------
 2784|  2.16k|                {
 2785|  2.16k|                    return false;
 2786|  2.16k|                }
 2787|       |
 2788|      0|                const auto &chunk = *it;
 2789|      0|                for (auto &choice : flag.HelpChoices(helpParams))
  ------------------
  |  Branch (2789:35): [True: 0, False: 0]
  ------------------
 2790|      0|                {
 2791|      0|                    AddCompletionReply(chunk, choice);
 2792|      0|                }
 2793|       |
 2794|      0|#ifndef ARGS_NOEXCEPT
 2795|      0|                throw Completion(completion->Get());
 2796|       |#else
 2797|       |                return true;
 2798|       |#endif
 2799|  2.16k|            }
_ZN4args14ArgumentParser10ParseShortINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SD_:
 2976|  1.10k|            {
 2977|  1.10k|                const auto &chunk = *it;
 2978|  1.10k|                const auto argchunk = chunk.substr(shortprefix.size());
 2979|  3.10k|                for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
  ------------------
  |  Branch (2979:57): [True: 2.50k, False: 606]
  ------------------
 2980|  2.50k|                {
 2981|  2.50k|                    const auto arg = *argit;
 2982|       |
 2983|  2.50k|                    if (auto flag = Match(arg))
  ------------------
  |  Branch (2983:30): [True: 2.35k, False: 151]
  ------------------
 2984|  2.35k|                    {
 2985|       |#ifdef ARGS_NOEXCEPT
 2986|       |                        // See ParseLong: if Match recorded an error
 2987|       |                        // (e.g. Options::Single violation), bail before the
 2988|       |                        // value is parsed so the prior value is preserved.
 2989|       |                        if (flag->GetError() != Error::None)
 2990|       |                        {
 2991|       |                            return false;
 2992|       |                        }
 2993|       |#endif
 2994|  2.35k|                        const std::string value(argit + 1, std::end(argchunk));
 2995|  2.35k|                        std::vector<std::string> values;
 2996|  2.35k|                        const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
 2997|  2.35k|                                                                         allowSeparateShortValue, allowJoinedShortValue,
 2998|  2.35k|                                                                         !value.empty(), value, !value.empty(), values);
 2999|       |
 3000|  2.35k|                        if (!errorMessage.empty())
  ------------------
  |  Branch (3000:29): [True: 2, False: 2.34k]
  ------------------
 3001|      2|                        {
 3002|      2|#ifndef ARGS_NOEXCEPT
 3003|      2|                            throw ParseError(errorMessage);
 3004|       |#else
 3005|       |                            error = Error::Parse;
 3006|       |                            errorMsg = errorMessage;
 3007|       |                            return false;
 3008|       |#endif
 3009|      2|                        }
 3010|       |
 3011|  2.34k|                        if (!readCompletion)
  ------------------
  |  Branch (3011:29): [True: 2.34k, False: 0]
  ------------------
 3012|  2.34k|                        {
 3013|  2.34k|                            flag->ParseValue(values);
 3014|       |#ifdef ARGS_NOEXCEPT
 3015|       |                            // See ParseLong: ensure a flag-level error from
 3016|       |                            // ParseValue (Help, Parse, Map) halts parsing so
 3017|       |                            // it cannot be shadowed by a later parser error.
 3018|       |                            if (flag->GetError() != Error::None)
 3019|       |                            {
 3020|       |                                return false;
 3021|       |                            }
 3022|       |#endif
 3023|  2.34k|                        }
 3024|       |
 3025|  2.34k|                        if (flag->KickOut())
  ------------------
  |  Branch (3025:29): [True: 0, False: 2.34k]
  ------------------
 3026|      0|                        {
 3027|      0|                            ++it;
 3028|      0|                            return false;
 3029|      0|                        }
 3030|       |
 3031|  2.34k|                        if (!values.empty())
  ------------------
  |  Branch (3031:29): [True: 348, False: 2.00k]
  ------------------
 3032|    348|                        {
 3033|    348|                            break;
 3034|    348|                        }
 3035|  2.34k|                    } else
 3036|    151|                    {
 3037|    151|                        const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
 3038|    151|#ifndef ARGS_NOEXCEPT
 3039|    151|                        throw ParseError(errorMessage);
 3040|       |#else
 3041|       |                        error = Error::Parse;
 3042|       |                        errorMsg = errorMessage;
 3043|       |                        return false;
 3044|       |#endif
 3045|    151|                    }
 3046|  2.50k|                }
 3047|       |
 3048|    954|                return true;
 3049|  1.10k|            }
_ZNK4args4Base7KickOutEv:
 1124|  7.67k|            {
 1125|  7.67k|                return (options & Options::KickOut) != Options::None;
 1126|  7.67k|            }
_ZN4args9ValueFlagIiNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKib:
 4139|  1.74k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None)
  ------------------
  |  Branch (4139:241): [True: 0, False: 1.74k]
  ------------------
 4140|  1.74k|            {
 4141|  1.74k|            }
_ZN4args9ValueFlagIiNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKiNS_7OptionsE:
 4134|  3.48k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_)
 4135|  3.48k|            {
 4136|  3.48k|                group_.Add(*this);
 4137|  3.48k|            }
_ZN4args13ValueFlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE:
 1483|  13.9k|            ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : FlagBase(name_, help_, std::move(matcher_), options_) {}
_ZN4args9ValueFlagIiNS_11ValueReaderEE5ResetEv:
 4164|  10.4k|            {
 4165|  10.4k|                ValueFlagBase::Reset();
 4166|  10.4k|                value = defaultValue;
 4167|  10.4k|            }
_ZNK4args13ValueFlagBase17NumberOfArgumentsEv:
 1487|  2.53k|            {
 1488|  2.53k|                return 1;
 1489|  2.53k|            }
_ZN4args9ValueFlagIiNS_11ValueReaderEE10ParseValueERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
 4150|    113|            {
 4151|    113|                const std::string &value_ = values_.at(0);
 4152|       |
 4153|       |#ifdef ARGS_NOEXCEPT
 4154|       |                if (!reader(name, value_, this->value))
 4155|       |                {
 4156|       |                    error = Error::Parse;
 4157|       |                }
 4158|       |#else
 4159|    113|                reader(name, value_, this->value);
 4160|    113|#endif
 4161|    113|            }
_ZN4args11ValueReaderclIiEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_:
 4085|    367|        {
 4086|    367|            const bool success = ParseNumericValue(value, destination);
 4087|    367|            if (!success)
  ------------------
  |  Branch (4087:17): [True: 86, False: 281]
  ------------------
 4088|     86|            {
 4089|       |#ifdef ARGS_NOEXCEPT
 4090|       |                (void)name;
 4091|       |                return false;
 4092|       |#else
 4093|     86|                std::ostringstream problem;
 4094|     86|                problem << "Argument '" << name << "' received invalid value type '" << value << "'";
 4095|     86|                throw ParseError(problem.str());
 4096|     86|#endif
 4097|     86|            }
 4098|    281|            return true;
 4099|    367|        }
_ZN4args11ValueReader17ParseNumericValueIiEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_:
 3968|    367|        {
 3969|    367|            if (HasUnsignedNegativeSign<T>(value))
  ------------------
  |  Branch (3969:17): [True: 0, False: 367]
  ------------------
 3970|      0|            {
 3971|      0|                return false;
 3972|      0|            }
 3973|       |
 3974|    367|            const char *begin = value.c_str();
 3975|       |            // The true end of the value, derived from its length rather than
 3976|       |            // from the first NUL. strtoull/strtoll treat the buffer as a C
 3977|       |            // string and stop at an embedded '\0', so checking `*end == '\0'`
 3978|       |            // for "no trailing data" is defeated by a value like "12\0junk":
 3979|       |            // end lands on the embedded NUL and the junk after it is silently
 3980|       |            // accepted. Comparing against `stop` validates the whole string
 3981|       |            // and matches the istringstream-based reader used for other types.
 3982|    367|            const char *const stop = begin + value.size();
 3983|       |
 3984|       |            // C++11-compatible: use strtoull/strtoll. Hardening retained from
 3985|       |            // the original from_chars draft (errno save/restore, ERANGE check,
 3986|       |            // narrowing range check, trailing-whitespace tolerance). No
 3987|       |            // unconditional dependency on <charconv> / C++17.
 3988|    367|            const int saved_errno = errno;
 3989|    367|            errno = 0;
 3990|       |
 3991|    367|            char *end = nullptr;
 3992|       |
 3993|    367|            if (std::is_unsigned<T>::value)
  ------------------
  |  Branch (3993:17): [Folded, False: 367]
  ------------------
 3994|      0|            {
 3995|      0|                const unsigned long long parsed = std::strtoull(begin, &end, 0);
 3996|      0|                if (end == begin)
  ------------------
  |  Branch (3996:21): [True: 0, False: 0]
  ------------------
 3997|      0|                {
 3998|      0|                    errno = saved_errno;
 3999|      0|                    return false;
 4000|      0|                }
 4001|      0|                while (end != stop && std::isspace(static_cast<unsigned char>(*end)))
  ------------------
  |  Branch (4001:24): [True: 0, False: 0]
  |  Branch (4001:39): [True: 0, False: 0]
  ------------------
 4002|      0|                {
 4003|      0|                    ++end;
 4004|      0|                }
 4005|      0|                if (end != stop || errno == ERANGE ||
  ------------------
  |  Branch (4005:21): [True: 0, False: 0]
  |  Branch (4005:36): [True: 0, False: 0]
  ------------------
 4006|      0|                    parsed > static_cast<unsigned long long>(std::numeric_limits<T>::max()))
  ------------------
  |  Branch (4006:21): [True: 0, False: 0]
  ------------------
 4007|      0|                {
 4008|      0|                    errno = saved_errno;
 4009|      0|                    return false;
 4010|      0|                }
 4011|       |
 4012|      0|                destination = static_cast<T>(parsed);
 4013|      0|            }
 4014|    367|            else
 4015|    367|            {
 4016|    367|                const long long parsed = std::strtoll(begin, &end, 0);
 4017|    367|                if (end == begin)
  ------------------
  |  Branch (4017:21): [True: 20, False: 347]
  ------------------
 4018|     20|                {
 4019|     20|                    errno = saved_errno;
 4020|     20|                    return false;
 4021|     20|                }
 4022|    433|                while (end != stop && std::isspace(static_cast<unsigned char>(*end)))
  ------------------
  |  Branch (4022:24): [True: 94, False: 339]
  |  Branch (4022:39): [True: 86, False: 8]
  ------------------
 4023|     86|                {
 4024|     86|                    ++end;
 4025|     86|                }
 4026|    347|                if (end != stop || errno == ERANGE ||
  ------------------
  |  Branch (4026:21): [True: 8, False: 339]
  |  Branch (4026:36): [True: 0, False: 339]
  ------------------
 4027|    339|                    parsed < static_cast<long long>(std::numeric_limits<T>::min()) ||
  ------------------
  |  Branch (4027:21): [True: 57, False: 282]
  ------------------
 4028|    282|                    parsed > static_cast<long long>(std::numeric_limits<T>::max()))
  ------------------
  |  Branch (4028:21): [True: 1, False: 281]
  ------------------
 4029|     66|                {
 4030|     66|                    errno = saved_errno;
 4031|     66|                    return false;
 4032|     66|                }
 4033|       |
 4034|    281|                destination = static_cast<T>(parsed);
 4035|    281|            }
 4036|       |
 4037|    367|            errno = saved_errno;
 4038|    281|            return true;
 4039|    367|        }
_ZN4args11ValueReader23HasUnsignedNegativeSignIiEENSt3__19enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 3954|    367|        {
 3955|    367|            return false;
 3956|    367|        }
_ZN4args9ValueFlagIdNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKdb:
 4139|  1.74k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None)
  ------------------
  |  Branch (4139:241): [True: 0, False: 1.74k]
  ------------------
 4140|  1.74k|            {
 4141|  1.74k|            }
_ZN4args9ValueFlagIdNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKdNS_7OptionsE:
 4134|  1.74k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_)
 4135|  1.74k|            {
 4136|  1.74k|                group_.Add(*this);
 4137|  1.74k|            }
_ZN4args9ValueFlagIdNS_11ValueReaderEE5ResetEv:
 4164|  5.22k|            {
 4165|  5.22k|                ValueFlagBase::Reset();
 4166|  5.22k|                value = defaultValue;
 4167|  5.22k|            }
_ZN4args9ValueFlagIdNS_11ValueReaderEE10ParseValueERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
 4150|     99|            {
 4151|     99|                const std::string &value_ = values_.at(0);
 4152|       |
 4153|       |#ifdef ARGS_NOEXCEPT
 4154|       |                if (!reader(name, value_, this->value))
 4155|       |                {
 4156|       |                    error = Error::Parse;
 4157|       |                }
 4158|       |#else
 4159|     99|                reader(name, value_, this->value);
 4160|     99|#endif
 4161|     99|            }
_ZN4args11ValueReaderclIdEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_:
 4085|     99|        {
 4086|     99|            const bool success = ParseNumericValue(value, destination);
 4087|     99|            if (!success)
  ------------------
  |  Branch (4087:17): [True: 10, False: 89]
  ------------------
 4088|     10|            {
 4089|       |#ifdef ARGS_NOEXCEPT
 4090|       |                (void)name;
 4091|       |                return false;
 4092|       |#else
 4093|     10|                std::ostringstream problem;
 4094|     10|                problem << "Argument '" << name << "' received invalid value type '" << value << "'";
 4095|     10|                throw ParseError(problem.str());
 4096|     10|#endif
 4097|     10|            }
 4098|     89|            return true;
 4099|     99|        }
_ZN4args11ValueReader17ParseNumericValueIdEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_:
 4050|     99|        {
 4051|     99|            std::istringstream ss(value);
 4052|       |            // Pin parsing to the C locale so that the decimal separator and
 4053|       |            // thousands grouping behavior do not silently depend on whatever
 4054|       |            // std::locale::global was last set to elsewhere in the process.
 4055|       |            // Without this, e.g. "3.14" parses as 3 (with ".14" trailing) in
 4056|       |            // any locale whose numpunct facet treats ',' as the decimal point.
 4057|     99|            ss.imbue(std::locale::classic());
 4058|     99|            ss >> destination;
 4059|     99|            if (ss.fail())
  ------------------
  |  Branch (4059:17): [True: 3, False: 96]
  ------------------
 4060|      3|            {
 4061|      3|                return false;
 4062|      3|            }
 4063|       |
 4064|       |            // Check for trailing garbage by attempting to extract any remaining characters.
 4065|       |            // Do not use 'ss >> std::ws' followed by peek(), as std::ws can set failbit
 4066|       |            // on EOF, causing false rejection of valid input.
 4067|     96|            char extra = '\0';
 4068|     96|            ss >> std::ws >> extra;
 4069|       |            // If extraction succeeded, there's trailing garbage (return false).
 4070|       |            // If extraction failed due to EOF only (goodbit after ws extraction), it's valid (return true).
 4071|       |            // If extraction failed for other reasons, it's invalid (return false).
 4072|     96|            if (ss.fail())
  ------------------
  |  Branch (4072:17): [True: 89, False: 7]
  ------------------
 4073|     89|            {
 4074|       |                // Clear the failbit to check if EOF is the only issue
 4075|     89|                ss.clear(ss.rdstate() & ~std::ios::failbit);
 4076|     89|                return ss.eof();
 4077|     89|            }
 4078|       |            // Extraction succeeded, meaning there's trailing garbage
 4079|      7|            return false;
 4080|     96|        }
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_ONS_7MatcherESD_b:
 4139|  1.74k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None)
  ------------------
  |  Branch (4139:241): [True: 0, False: 1.74k]
  ------------------
 4140|  1.74k|            {
 4141|  1.74k|            }
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_ONS_7MatcherESD_NS_7OptionsE:
 4134|  3.48k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_)
 4135|  3.48k|            {
 4136|  3.48k|                group_.Add(*this);
 4137|  3.48k|            }
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE5ResetEv:
 4164|  10.4k|            {
 4165|  10.4k|                ValueFlagBase::Reset();
 4166|  10.4k|                value = defaultValue;
 4167|  10.4k|            }
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE10ParseValueERKNS1_6vectorIS7_NS5_IS7_EEEE:
 4150|  1.82k|            {
 4151|  1.82k|                const std::string &value_ = values_.at(0);
 4152|       |
 4153|       |#ifdef ARGS_NOEXCEPT
 4154|       |                if (!reader(name, value_, this->value))
 4155|       |                {
 4156|       |                    error = Error::Parse;
 4157|       |                }
 4158|       |#else
 4159|  1.82k|                reader(name, value_, this->value);
 4160|  1.82k|#endif
 4161|  1.82k|            }
_ZN4args11ValueReaderclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr3std13is_assignableIT_S8_EE5valueEbE4typeERKS8_SE_RSA_:
 4104|  6.66k|        {
 4105|  6.66k|            destination = value;
 4106|  6.66k|            return true;
 4107|  6.66k|        }
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEED2Ev:
 4147|  3.48k|            virtual ~ValueFlag() {}
_ZN4args17ImplicitValueFlagIiNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKiSH_NS_7OptionsE:
 4228|  1.74k|                : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(implicitValue_)
 4229|  1.74k|            {
 4230|  1.74k|            }
_ZNK4args17ImplicitValueFlagIiNS_11ValueReaderEE17NumberOfArgumentsEv:
 4245|    159|            {
 4246|    159|                return {0, 1};
 4247|    159|            }
_ZN4args17ImplicitValueFlagIiNS_11ValueReaderEE10ParseValueERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
 4250|    159|            {
 4251|    159|                if (value_.empty())
  ------------------
  |  Branch (4251:21): [True: 88, False: 71]
  ------------------
 4252|     88|                {
 4253|     88|                    this->value = implicitValue;
 4254|     88|                } else
 4255|     71|                {
 4256|     71|                    ValueFlag<T, Reader>::ParseValue(value_);
 4257|     71|                }
 4258|    159|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEESF_ONS_7MatcherERKNS7_6vectorIiNSB_IiEEEENS_7OptionsE:
 4481|  1.74k|                ValueFlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_)
 4482|  1.74k|            {
 4483|  1.74k|                group_.Add(*this);
 4484|  1.74k|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEE5MatchERKNS_10EitherFlagE:
 4552|  2.85k|            {
 4553|  2.85k|                const bool wasMatched = Matched();
 4554|  2.85k|                auto me = FlagBase::Match(arg);
 4555|  2.85k|                if (me && !wasMatched)
  ------------------
  |  Branch (4555:21): [True: 254, False: 2.60k]
  |  Branch (4555:27): [True: 178, False: 76]
  ------------------
 4556|    178|                {
 4557|    178|                    values.clear();
 4558|    178|                }
 4559|  2.85k|                return me;
 4560|  2.85k|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEE5ResetEv:
 4546|  5.22k|            {
 4547|  5.22k|                ValueFlagBase::Reset();
 4548|  5.22k|                values = defaultValues;
 4549|  5.22k|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEE10ParseValueERKNSt3__16vectorINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEE:
 4489|    254|            {
 4490|    254|                const std::string &value_ = values_.at(0);
 4491|       |
 4492|    254|                T v{};
 4493|       |#ifdef ARGS_NOEXCEPT
 4494|       |                if (!reader(name, value_, v))
 4495|       |                {
 4496|       |                    error = Error::Parse;
 4497|       |                    return;
 4498|       |                }
 4499|       |#else
 4500|    254|                reader(name, value_, v);
 4501|    254|#endif
 4502|    254|                values.insert(std::end(values), v);
 4503|    254|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEED2Ev:
 4486|  1.74k|            virtual ~ValueFlagList() {}
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEEC2ERNS_5GroupERKS7_SF_ONS_7MatcherENS_5NargsERKNS1_6vectorIS7_NS5_IS7_EEEENS_7OptionsE:
 4334|  1.74k|                : FlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_),nargs(nargs_)
 4335|  1.74k|            {
 4336|  1.74k|                group_.Add(*this);
 4337|  1.74k|            }
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5MatchERKNS_10EitherFlagE:
 4436|  2.60k|            {
 4437|  2.60k|                const bool wasMatched = Matched();
 4438|  2.60k|                auto me = FlagBase::Match(arg);
 4439|  2.60k|                if (me && !wasMatched)
  ------------------
  |  Branch (4439:21): [True: 241, False: 2.36k]
  |  Branch (4439:27): [True: 99, False: 142]
  ------------------
 4440|     99|                {
 4441|     99|                    values.clear();
 4442|     99|                }
 4443|  2.60k|                return me;
 4444|  2.60k|            }
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5ResetEv:
 4430|  5.22k|            {
 4431|  5.22k|                FlagBase::Reset();
 4432|  5.22k|                values = defaultValues;
 4433|  5.22k|            }
_ZNK4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE17NumberOfArgumentsEv:
 4342|    241|            {
 4343|    241|                return nargs;
 4344|    241|            }
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE10ParseValueERKNS1_6vectorIS7_NS5_IS7_EEEE:
 4347|    241|            {
 4348|    241|                values.clear();
 4349|       |
 4350|    241|                for (const std::string &value : values_)
  ------------------
  |  Branch (4350:47): [True: 175, False: 241]
  ------------------
 4351|    175|                {
 4352|    175|                    T v {};
 4353|       |#ifdef ARGS_NOEXCEPT
 4354|       |                    if (!reader(name, value, v))
 4355|       |                    {
 4356|       |                        error = Error::Parse;
 4357|       |                        return;
 4358|       |                    }
 4359|       |#else
 4360|    175|                    reader(name, value, v);
 4361|    175|#endif
 4362|    175|                    values.insert(std::end(values), v);
 4363|    175|                }
 4364|    241|            }
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEED2Ev:
 4339|  1.74k|            virtual ~NargsValueFlag() {}
_ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEC2ERNS_5GroupERKS7_SF_ONS_7MatcherERKNS1_13unordered_mapIS7_iNS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairISE_iEEEEEERKib:
 4626|  1.74k|            MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const T &defaultValue_ = T(), const bool extraError_ = false): MapFlag(group_, name_, help_, std::move(matcher_), map_, defaultValue_, extraError_ ? Options::Single : Options::None)
  ------------------
  |  Branch (4626:266): [True: 0, False: 1.74k]
  ------------------
 4627|  1.74k|            {
 4628|  1.74k|            }
_ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEC2ERNS_5GroupERKS7_SF_ONS_7MatcherERKNS1_13unordered_mapIS7_iNS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairISE_iEEEEEERKiNS_7OptionsE:
 4621|  1.74k|            MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), map(map_), value(defaultValue_), defaultValue(defaultValue_)
 4622|  1.74k|            {
 4623|  1.74k|                group_.Add(*this);
 4624|  1.74k|            }
_ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE5ResetEv:
 4703|  5.22k|            {
 4704|  5.22k|                ValueFlagBase::Reset();
 4705|  5.22k|                value = defaultValue;
 4706|  5.22k|            }
_ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE10ParseValueERKNS1_6vectorIS7_NS5_IS7_EEEE:
 4637|     85|            {
 4638|     85|                const std::string &value_ = values_.at(0);
 4639|       |
 4640|     85|                K key{};
 4641|       |#ifdef ARGS_NOEXCEPT
 4642|       |                if (!reader(name, value_, key))
 4643|       |                {
 4644|       |                    error = Error::Parse;
 4645|       |                    return;
 4646|       |                }
 4647|       |#else
 4648|     85|                reader(name, value_, key);
 4649|     85|#endif
 4650|     85|                auto it = map.find(key);
 4651|     85|                if (it == std::end(map))
  ------------------
  |  Branch (4651:21): [True: 37, False: 48]
  ------------------
 4652|     37|                {
 4653|     37|                    std::ostringstream problem;
 4654|     37|                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
 4655|       |#ifdef ARGS_NOEXCEPT
 4656|       |                    error = Error::Map;
 4657|       |                    errorMsg = problem.str();
 4658|       |#else
 4659|     37|                    throw MapError(problem.str());
 4660|     37|#endif
 4661|     37|                } else
 4662|     48|                {
 4663|     48|                    this->value = it->second;
 4664|     48|                }
 4665|     85|            }
_ZN4args8MapErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  525|  1.15k|            MapError(const std::string &problem) : ParseError(problem) {}
_ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEED2Ev:
 4634|  1.74k|            virtual ~MapFlag() {}
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEEC2ERNS_5GroupERKS7_SG_ONS_7MatcherERKNS1_13unordered_mapIS7_iNS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairISF_iEEEEEERKNS1_6vectorIiNS5_IiEEEENS_7OptionsE:
 4753|  1.74k|                ValueFlagBase(name_, help_, std::move(matcher_), options_), map(map_), values(defaultValues_), defaultValues(defaultValues_)
 4754|  1.74k|            {
 4755|  1.74k|                group_.Add(*this);
 4756|  1.74k|            }
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEE5MatchERKNS_10EitherFlagE:
 4838|  2.27k|            {
 4839|  2.27k|                const bool wasMatched = Matched();
 4840|  2.27k|                auto me = FlagBase::Match(arg);
 4841|  2.27k|                if (me && !wasMatched)
  ------------------
  |  Branch (4841:21): [True: 226, False: 2.05k]
  |  Branch (4841:27): [True: 47, False: 179]
  ------------------
 4842|     47|                {
 4843|     47|                    values.clear();
 4844|     47|                }
 4845|  2.27k|                return me;
 4846|  2.27k|            }
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEE5ResetEv:
 4832|  5.22k|            {
 4833|  5.22k|                ValueFlagBase::Reset();
 4834|  5.22k|                values = defaultValues;
 4835|  5.22k|            }
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEE10ParseValueERKNS1_6vectorIS7_NS5_IS7_EEEE:
 4761|    226|            {
 4762|    226|                const std::string &value_ = values_.at(0);
 4763|       |
 4764|    226|                K key{};
 4765|       |#ifdef ARGS_NOEXCEPT
 4766|       |                if (!reader(name, value_, key))
 4767|       |                {
 4768|       |                    error = Error::Parse;
 4769|       |                    return;
 4770|       |                }
 4771|       |#else
 4772|    226|                reader(name, value_, key);
 4773|    226|#endif
 4774|    226|                auto it = map.find(key);
 4775|    226|                if (it == std::end(map))
  ------------------
  |  Branch (4775:21): [True: 14, False: 212]
  ------------------
 4776|     14|                {
 4777|     14|                    std::ostringstream problem;
 4778|     14|                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
 4779|       |#ifdef ARGS_NOEXCEPT
 4780|       |                    error = Error::Map;
 4781|       |                    errorMsg = problem.str();
 4782|       |#else
 4783|     14|                    throw MapError(problem.str());
 4784|     14|#endif
 4785|     14|                } else
 4786|    212|                {
 4787|    212|                    detail::AppendMappedValue(values, it->second, 0);
 4788|    212|                }
 4789|    226|            }
_ZN4args6detail17AppendMappedValueINSt3__16vectorIiNS2_9allocatorIiEEEEiEEDTcmcldtfp_12emplace_backfp0_Ecvv_EERT_RKT0_i:
 1286|    212|        {
 1287|    212|            container.emplace_back(value);
 1288|    212|        }
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEED2Ev:
 4758|  1.74k|            virtual ~MapFlagList() {}
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_ONS_7MatcherENS_7OptionsE:
 4143|  1.74k|            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): ValueFlag(group_, name_, help_, std::move(matcher_), T(), options_)
 4144|  1.74k|            {
 4145|  1.74k|            }
_ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_SD_NS_7OptionsE:
 4894|  1.74k|            Positional(Group &group_, const std::string &name_, const std::string &help_, const T &defaultValue_ = T(), Options options_ = {}): PositionalBase(name_, help_, options_), value(defaultValue_), defaultValue(defaultValue_)
 4895|  1.74k|            {
 4896|  1.74k|                group_.Add(*this);
 4897|  1.74k|            }
_ZN4args14PositionalBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_7OptionsE:
 1601|  5.22k|            PositionalBase(const std::string &name_, const std::string &help_, Options options_ = {}) : NamedBase(name_, help_, options_), ready(true) {}
_ZN4args14PositionalBase5ResetEv:
 1612|  15.6k|            {
 1613|  15.6k|                matched = false;
 1614|  15.6k|                ready = true;
 1615|       |#ifdef ARGS_NOEXCEPT
 1616|       |                error = Error::None;
 1617|       |                errorMsg.clear();
 1618|       |#endif
 1619|  15.6k|            }
_ZNK4args14PositionalBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 1638|  5.22k|            {
 1639|  5.22k|                if (IsRequired() && !Matched())
  ------------------
  |  Branch (1639:21): [True: 0, False: 5.22k]
  |  Branch (1639:37): [True: 0, False: 0]
  ------------------
 1640|      0|                {
 1641|      0|                    std::ostringstream problem;
 1642|      0|                    problem << "Option '" << Name() << "' is required";
 1643|       |#ifdef ARGS_NOEXCEPT
 1644|       |                    error = Error::Required;
 1645|       |                    errorMsg = problem.str();
 1646|       |#else
 1647|      0|                    throw RequiredError(problem.str());
 1648|      0|#endif
 1649|      0|                }
 1650|  5.22k|            }
_ZN4args14PositionalBase17GetNextPositionalEv:
 1622|  5.90k|            {
 1623|  5.90k|                return Ready() ? this : nullptr;
  ------------------
  |  Branch (1623:24): [True: 4.35k, False: 1.55k]
  ------------------
 1624|  5.90k|            }
_ZN4args14PositionalBase5ReadyEv:
 1605|  5.90k|            {
 1606|  5.90k|                return ready;
 1607|  5.90k|            }
_ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE5ResetEv:
 4956|  5.22k|            {
 4957|  5.22k|                PositionalBase::Reset();
 4958|  5.22k|                value = defaultValue;
 4959|  5.22k|            }
_ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE10ParseValueERKS7_:
 4906|  3.00k|            {
 4907|       |#ifdef ARGS_NOEXCEPT
 4908|       |                if (!reader(name, value_, this->value))
 4909|       |                {
 4910|       |                    error = Error::Parse;
 4911|       |                    return;
 4912|       |                }
 4913|       |#else
 4914|  3.00k|                reader(name, value_, this->value);
 4915|  3.00k|#endif
 4916|  3.00k|                ready = false;
 4917|  3.00k|                matched = true;
 4918|  3.00k|            }
_ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEED2Ev:
 4903|  1.74k|            virtual ~Positional() {}
_ZN4args13MapPositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEC2ERNS_5GroupERKS7_SF_RKNS1_13unordered_mapIS7_iNS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairISE_iEEEEEERKiNS_7OptionsE:
 5138|  1.74k|                PositionalBase(name_, help_, options_), map(map_), value(defaultValue_), defaultValue(defaultValue_)
 5139|  1.74k|            {
 5140|  1.74k|                group_.Add(*this);
 5141|  1.74k|            }
_ZN4args13MapPositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE5ResetEv:
 5212|  5.22k|            {
 5213|  5.22k|                PositionalBase::Reset();
 5214|  5.22k|                value = defaultValue;
 5215|  5.22k|            }
_ZN4args13MapPositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE10ParseValueERKS7_:
 5146|  1.14k|            {
 5147|  1.14k|                K key{};
 5148|       |#ifdef ARGS_NOEXCEPT
 5149|       |                if (!reader(name, value_, key))
 5150|       |                {
 5151|       |                    error = Error::Parse;
 5152|       |                    return;
 5153|       |                }
 5154|       |#else
 5155|  1.14k|                reader(name, value_, key);
 5156|  1.14k|#endif
 5157|  1.14k|                auto it = map.find(key);
 5158|  1.14k|                if (it == std::end(map))
  ------------------
  |  Branch (5158:21): [True: 1.10k, False: 34]
  ------------------
 5159|  1.10k|                {
 5160|  1.10k|                    std::ostringstream problem;
 5161|  1.10k|                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
 5162|       |#ifdef ARGS_NOEXCEPT
 5163|       |                    error = Error::Map;
 5164|       |                    errorMsg = problem.str();
 5165|       |#else
 5166|  1.10k|                    throw MapError(problem.str());
 5167|  1.10k|#endif
 5168|  1.10k|                } else
 5169|     34|                {
 5170|     34|                    this->value = it->second;
 5171|     34|                    ready = false;
 5172|     34|                    matched = true;
 5173|     34|                }
 5174|  1.14k|            }
_ZN4args13MapPositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEED2Ev:
 5143|  1.74k|            virtual ~MapPositional() {}
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEEC2ERNS_5GroupERKS7_SF_RKNS1_6vectorIS7_NS5_IS7_EEEENS_7OptionsE:
 4994|  1.74k|            PositionalList(Group &group_, const std::string &name_, const std::string &help_, const Container &defaultValues_ = Container(), Options options_ = {}): PositionalBase(name_, help_, options_), values(defaultValues_), defaultValues(defaultValues_)
 4995|  1.74k|            {
 4996|  1.74k|                group_.Add(*this);
 4997|  1.74k|            }
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE17GetNextPositionalEv:
 5068|    204|            {
 5069|    204|                const bool wasMatched = Matched();
 5070|    204|                auto me = PositionalBase::GetNextPositional();
 5071|    204|                if (me && !wasMatched)
  ------------------
  |  Branch (5071:21): [True: 204, False: 0]
  |  Branch (5071:27): [True: 30, False: 174]
  ------------------
 5072|     30|                {
 5073|     30|                    values.clear();
 5074|     30|                }
 5075|    204|                return me;
 5076|    204|            }
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5ResetEv:
 5062|  5.22k|            {
 5063|  5.22k|                PositionalBase::Reset();
 5064|  5.22k|                values = defaultValues;
 5065|  5.22k|            }
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE10ParseValueERKS7_:
 5006|    204|            {
 5007|    204|                T v{};
 5008|       |#ifdef ARGS_NOEXCEPT
 5009|       |                if (!reader(name, value_, v))
 5010|       |                {
 5011|       |                    error = Error::Parse;
 5012|       |                    return;
 5013|       |                }
 5014|       |#else
 5015|    204|                reader(name, value_, v);
 5016|    204|#endif
 5017|    204|                values.insert(std::end(values), v);
 5018|    204|                matched = true;
 5019|    204|            }
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEED2Ev:
 5003|  1.74k|            virtual ~PositionalList() {}
_ZN4args9ValueFlagIiNS_11ValueReaderEEdeEv:
 4179|     91|            {
 4180|     91|                return value;
 4181|     91|            }
_ZN4args9ValueFlagIdNS_11ValueReaderEEdeEv:
 4179|     43|            {
 4180|     43|                return value;
 4181|     43|            }
_ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEdeEv:
 4179|     30|            {
 4180|     30|                return value;
 4181|     30|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEE5beginEv:
 4563|    178|            {
 4564|    178|                return values.begin();
 4565|    178|            }
_ZN4args13ValueFlagListIiNS_6detail6vectorENS_11ValueReaderEE3endEv:
 4578|    178|            {
 4579|    178|                return values.end();
 4580|    178|            }
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5beginEv:
 4400|     99|            {
 4401|     99|                return values.begin();
 4402|     99|            }
_ZN4args14NargsValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE3endEv:
 4415|     99|            {
 4416|     99|                return values.end();
 4417|     99|            }
_ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEdeEv:
 4677|     53|            {
 4678|     53|                return value;
 4679|     53|            }
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEE5beginEv:
 4849|     47|            {
 4850|     47|                return values.begin();
 4851|     47|            }
_ZN4args11MapFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_6detail6vectorENS_11ValueReaderENS8_13unordered_mapEE3endEv:
 4864|     47|            {
 4865|     47|                return values.end();
 4866|     47|            }
_ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEdeEv:
 4930|  1.26k|            {
 4931|  1.26k|                return value;
 4932|  1.26k|            }
_ZN4args13MapPositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEdeEv:
 5186|     34|            {
 5187|     34|                return value;
 5188|     34|            }
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5beginEv:
 5079|     30|            {
 5080|     30|                return values.begin();
 5081|     30|            }
_ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE3endEv:
 5094|     30|            {
 5095|     30|                return values.end();
 5096|     30|            }

LLVMFuzzerTestOneInput:
   75|  1.74k|{
   76|  1.74k|    FuzzedDataProvider fdp(data, size);
   77|       |
   78|  1.74k|    args::ArgumentParser parser("parse_schema_fuzzer", "typed value schema test");
   79|       |
   80|  1.74k|    args::HelpFlag help(parser, "help", "help", {'h', "help"});
   81|  1.74k|    args::Flag flag(parser, "flag", "flag", {'f', "flag"});
   82|  1.74k|    args::Flag once(parser, "once", "once", {'o'}, args::Options::Single);
   83|  1.74k|    args::CounterFlag count(parser, "count", "count", {'c', "count"});
   84|  1.74k|    args::ValueFlag<int> number(parser, "number", "number", {'n', "number"}, 0);
   85|  1.74k|    args::ValueFlag<double> ratio(parser, "ratio", "ratio", {"ratio"}, 0.0);
   86|  1.74k|    args::ValueFlag<std::string> label(parser, "label", "label", {'l', "label"}, std::string("x"));
   87|  1.74k|    args::ImplicitValueFlag<int> jobs(parser, "jobs", "jobs", {'j', "jobs"}, 0, 1);
   88|  1.74k|    args::ValueFlagList<int> numbers(parser, "nums", "nums", {'N', "nums"});
   89|  1.74k|    args::NargsValueFlag<std::string> pair(parser, "pair", "pair", {'P', "pair"}, args::Nargs(0, 2));
   90|  1.74k|    args::MapFlag<std::string, int> mode(parser, "mode", "mode", {'m', "mode"}, kModes);
   91|  1.74k|    args::MapFlagList<std::string, int> modes(parser, "modes", "modes", {"modes"}, kModes);
   92|  1.74k|    args::ValueFlag<std::string> required(parser, "req", "req", {"req"}, args::Options::Required);
   93|  1.74k|    args::Positional<std::string> src(parser, "src", "source");
   94|  1.74k|    args::MapPositional<std::string, int> posMode(parser, "posmode", "mapped positional", kModes);
   95|  1.74k|    args::PositionalList<std::string> dst(parser, "dst", "destinations");
   96|       |
   97|  1.74k|    const size_t tokenCount = fdp.ConsumeIntegralInRange<size_t>(1, 14);
   98|  1.74k|    std::vector<std::string> argv;
   99|  1.74k|    argv.reserve(tokenCount);
  100|  16.7k|    for (size_t i = 0; i < tokenCount; ++i)
  ------------------
  |  Branch (100:24): [True: 14.9k, False: 1.74k]
  ------------------
  101|  14.9k|    {
  102|  14.9k|        if (fdp.ConsumeBool())
  ------------------
  |  Branch (102:13): [True: 2.59k, False: 12.3k]
  ------------------
  103|  2.59k|        {
  104|  2.59k|            argv.emplace_back(kTokens[fdp.ConsumeIntegralInRange<size_t>(0, ArraySize(kTokens) - 1)]);
  105|  2.59k|        }
  106|  12.3k|        else
  107|  12.3k|        {
  108|  12.3k|            argv.emplace_back(fdp.ConsumeRandomLengthString(16));
  109|  12.3k|        }
  110|  14.9k|    }
  111|       |
  112|       |    // ParseArgs legitimately throws only args::Error subtypes; anything
  113|       |    // else escaping is a library bug and traps the fuzzer.
  114|  1.74k|    try
  115|  1.74k|    {
  116|  1.74k|        parser.ParseArgs(argv);
  117|  1.74k|    }
  118|  1.74k|    catch (const args::Error &)
  119|  1.74k|    {
  120|  1.73k|    }
  121|  1.74k|    catch (...)
  122|  1.74k|    {
  123|      0|        __builtin_trap();
  124|      0|    }
  125|       |
  126|       |    // -- Read back every typed result so getters and iterators instantiate ----
  127|  1.74k|    (void)count.Get();
  128|  1.74k|    if (number)
  ------------------
  |  Branch (128:9): [True: 20, False: 1.72k]
  ------------------
  129|     20|    {
  130|     20|        (void)*number;
  131|     20|    }
  132|  1.74k|    if (ratio)
  ------------------
  |  Branch (132:9): [True: 43, False: 1.69k]
  ------------------
  133|     43|    {
  134|     43|        (void)*ratio;
  135|     43|    }
  136|  1.74k|    if (label)
  ------------------
  |  Branch (136:9): [True: 30, False: 1.71k]
  ------------------
  137|     30|    {
  138|     30|        (void)*label;
  139|     30|    }
  140|  1.74k|    if (jobs)
  ------------------
  |  Branch (140:9): [True: 71, False: 1.66k]
  ------------------
  141|     71|    {
  142|     71|        (void)*jobs;
  143|     71|    }
  144|  1.74k|    if (numbers)
  ------------------
  |  Branch (144:9): [True: 178, False: 1.56k]
  ------------------
  145|    178|    {
  146|    178|        for (const int &value : numbers)
  ------------------
  |  Branch (146:31): [True: 188, False: 178]
  ------------------
  147|    188|        {
  148|    188|            (void)value;
  149|    188|        }
  150|    178|    }
  151|  1.74k|    if (pair)
  ------------------
  |  Branch (151:9): [True: 99, False: 1.64k]
  ------------------
  152|     99|    {
  153|     99|        for (const std::string &value : pair)
  ------------------
  |  Branch (153:39): [True: 113, False: 99]
  ------------------
  154|    113|        {
  155|    113|            (void)value;
  156|    113|        }
  157|     99|    }
  158|  1.74k|    if (mode)
  ------------------
  |  Branch (158:9): [True: 53, False: 1.68k]
  ------------------
  159|     53|    {
  160|     53|        (void)*mode;
  161|     53|    }
  162|  1.74k|    if (modes)
  ------------------
  |  Branch (162:9): [True: 47, False: 1.69k]
  ------------------
  163|     47|    {
  164|     47|        for (const int &value : modes)
  ------------------
  |  Branch (164:31): [True: 212, False: 47]
  ------------------
  165|    212|        {
  166|    212|            (void)value;
  167|    212|        }
  168|     47|    }
  169|  1.74k|    if (src)
  ------------------
  |  Branch (169:9): [True: 1.26k, False: 476]
  ------------------
  170|  1.26k|    {
  171|  1.26k|        (void)*src;
  172|  1.26k|    }
  173|  1.74k|    if (posMode)
  ------------------
  |  Branch (173:9): [True: 34, False: 1.70k]
  ------------------
  174|     34|    {
  175|     34|        (void)*posMode;
  176|     34|    }
  177|  1.74k|    if (dst)
  ------------------
  |  Branch (177:9): [True: 30, False: 1.71k]
  ------------------
  178|     30|    {
  179|     30|        for (const std::string &value : dst)
  ------------------
  |  Branch (179:39): [True: 204, False: 30]
  ------------------
  180|    204|        {
  181|    204|            (void)value;
  182|    204|        }
  183|     30|    }
  184|       |
  185|       |    // -- Re-parse pair: invalid parse (validation error) then known-good parse
  186|  1.74k|    try
  187|  1.74k|    {
  188|  1.74k|        parser.ParseArgs(std::vector<std::string>{});
  189|  1.74k|    }
  190|  1.74k|    catch (const args::Error &)
  191|  1.74k|    {
  192|  1.74k|    }
  193|  1.74k|    catch (...)
  194|  1.74k|    {
  195|      0|        __builtin_trap();
  196|      0|    }
  197|       |
  198|  1.74k|    try
  199|  1.74k|    {
  200|  1.74k|        parser.ParseArgs(std::vector<std::string>{"--req", "ok", "src.txt"});
  201|  1.74k|    }
  202|  1.74k|    catch (const args::Error &)
  203|  1.74k|    {
  204|      0|    }
  205|  1.74k|    catch (...)
  206|  1.74k|    {
  207|      0|        __builtin_trap();
  208|      0|    }
  209|       |
  210|  1.74k|    return 0;
  211|  1.74k|}
parse_schema_fuzzer.cpp:_ZN12_GLOBAL__N_19ArraySizeIKPKcLm65EEEmRAT0__T_:
   68|  2.59k|{
   69|  2.59k|    return N;
   70|  2.59k|}