_ZN4args14ArgumentParserC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 3200|    875|            {
 3201|    875|                Description(description_);
 3202|    875|                Epilog(epilog_);
 3203|    875|                LongPrefix("--");
 3204|    875|                ShortPrefix("-");
 3205|    875|                LongSeparator("=");
 3206|    875|                Terminator("--");
 3207|    875|                SetArgumentSeparations(true, true, true, true);
 3208|    875|                matched = true;
 3209|    875|            }
_ZN4args7CommandC2Ev:
 2081|    875|            Command() = default;
_ZN4args5GroupC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_8functionIFbRKS0_EEENS_7OptionsE:
 1704|    875|            Group(const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_) {}
_ZN4args4BaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7OptionsE:
 1095|  3.50k|            Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
_ZNK4args4Base7MatchedEv:
 1109|  13.6k|            {
 1110|  13.6k|                return matched;
 1111|  13.6k|            }
_ZN4args4Base11GetCommandsEv:
 1131|  2.62k|            {
 1132|  2.62k|                return {};
 1133|  2.62k|            }
_ZNK4args4Base7IsGroupEv:
 1136|     39|            {
 1137|     39|                return false;
 1138|     39|            }
_ZN4args4Base17GetNextPositionalEv:
 1146|    585|            {
 1147|    585|                return nullptr;
 1148|    585|            }
_ZNK4args4Base10HasCommandEv:
 1166|     39|            {
 1167|     39|                return false;
 1168|     39|            }
_ZN4args4Base5ResetEv:
 1195|  3.50k|            {
 1196|  3.50k|                matched = false;
 1197|       |#ifdef ARGS_NOEXCEPT
 1198|       |                error = Error::None;
 1199|       |                errorMsg.clear();
 1200|       |#endif
 1201|  3.50k|            }
_ZN4args4BaseD2Ev:
 1096|  3.50k|            virtual ~Base() {}
_ZN4args5GroupD2Ev:
 1710|    875|            virtual ~Group() {}
_ZNK4args5Group8ChildrenEv:
 1722|  14.5k|            {
 1723|  14.5k|                return children;
 1724|  14.5k|            }
_ZN4argsanENS_7OptionsES0_:
  880|  23.7k|    {
  881|  23.7k|        return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
  882|  23.7k|    }
_ZNK4args4Base10GetOptionsEv:
 1099|  11.9k|            {
 1100|  11.9k|                return options;
 1101|  11.9k|            }
_ZN4args5Group11GetCommandsEv:
 1880|    875|            {
 1881|    875|                std::vector<Command*> res;
 1882|    875|                for (const auto &child : Children())
  ------------------
  |  Branch (1882:40): [True: 2.62k, False: 875]
  ------------------
 1883|  2.62k|                {
 1884|  2.62k|                    auto subparsers = child->GetCommands();
 1885|  2.62k|                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
 1886|  2.62k|                }
 1887|    875|                return res;
 1888|    875|            }
_ZN4args5Group5MatchERKNS_10EitherFlagE:
 1732|  12.5k|            {
 1733|  12.5k|                for (Base *child: Children())
  ------------------
  |  Branch (1733:33): [True: 35.4k, False: 627]
  ------------------
 1734|  35.4k|                {
 1735|  35.4k|                    if (FlagBase *match = child->Match(flag))
  ------------------
  |  Branch (1735:35): [True: 11.8k, False: 23.5k]
  ------------------
 1736|  11.8k|                    {
 1737|  11.8k|                        return match;
 1738|  11.8k|                    }
 1739|  35.4k|                }
 1740|    627|                return nullptr;
 1741|  12.5k|            }
_ZN4args5Group17GetNextPositionalEv:
 1767|    195|            {
 1768|    195|                for (Base *child: Children())
  ------------------
  |  Branch (1768:33): [True: 585, False: 195]
  ------------------
 1769|    585|                {
 1770|    585|                    if (auto next = child->GetNextPositional())
  ------------------
  |  Branch (1770:30): [True: 0, False: 585]
  ------------------
 1771|      0|                    {
 1772|      0|                        return next;
 1773|      0|                    }
 1774|    585|                }
 1775|    195|                return nullptr;
 1776|    195|            }
_ZNK4args5Group10HasCommandEv:
 1801|     13|            {
 1802|     13|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
 1803|     13|            }
_ZZNK4args5Group10HasCommandEvENKUlPNS_4BaseEE_clES2_:
 1802|     39|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
_ZN4args5Group5ResetEv:
 1896|    875|            {
 1897|    875|                Base::Reset();
 1898|       |
 1899|    875|                for (auto &child: Children())
  ------------------
  |  Branch (1899:33): [True: 2.62k, False: 875]
  ------------------
 1900|  2.62k|                {
 1901|  2.62k|                    child->Reset();
 1902|  2.62k|                }
 1903|       |#ifdef ARGS_NOEXCEPT
 1904|       |                error = Error::None;
 1905|       |                errorMsg.clear();
 1906|       |#endif
 1907|    875|            }
_ZN4args7Command5ResetEv:
 2533|    875|            {
 2534|    875|                Group::Reset();
 2535|    875|                selectedCommand = nullptr;
 2536|    875|                subparserProgramLine.clear();
 2537|    875|                subparserDescription.clear();
 2538|    875|                subparserHasFlag = false;
 2539|    875|                subparserHasPositional = false;
 2540|    875|                subparserHasCommand = false;
 2541|       |#ifdef ARGS_NOEXCEPT
 2542|       |                subparserError = Error::None;
 2543|       |#endif
 2544|    875|            }
_ZN4args7Command11DescriptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2154|    875|            { this->description = description_; }
_ZN4args7Command6EpilogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2164|    875|            { this->epilog = epilog_; }
_ZN4args14ArgumentParser10LongPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3233|    875|            {
 3234|    875|                this->longprefix = longprefix_;
 3235|    875|                this->helpParams.longPrefix = longprefix_;
 3236|    875|            }
_ZN4args14ArgumentParser11ShortPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3245|    875|            {
 3246|    875|                this->shortprefix = shortprefix_;
 3247|    875|                this->helpParams.shortPrefix = shortprefix_;
 3248|    875|            }
_ZN4args14ArgumentParser13LongSeparatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3257|    875|            {
 3258|    875|                if (longseparator_.empty())
  ------------------
  |  Branch (3258:21): [True: 0, False: 875]
  ------------------
 3259|      0|                {
 3260|      0|                    const std::string errorMessage("longseparator can not be set to empty");
 3261|       |#ifdef ARGS_NOEXCEPT
 3262|       |                    error = Error::Usage;
 3263|       |                    errorMsg = errorMessage;
 3264|       |#else
 3265|      0|                    throw UsageError(errorMessage);
 3266|      0|#endif
 3267|      0|                } else
 3268|    875|                {
 3269|    875|                    this->longseparator = longseparator_;
 3270|    875|                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3270:54): [True: 875, False: 0]
  ------------------
 3271|    875|                }
 3272|    875|            }
_ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  551|    862|            Error(const std::string &problem) : std::runtime_error(problem) {}
_ZN4args14ArgumentParser10TerminatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3281|    875|            { this->terminator = terminator_; }
_ZN4args14ArgumentParser22SetArgumentSeparationsEbbbb:
 3311|    875|            {
 3312|    875|                this->allowJoinedShortValue = allowJoinedShortValue_;
 3313|    875|                this->allowJoinedLongValue = allowJoinedLongValue_;
 3314|    875|                this->allowSeparateShortValue = allowSeparateShortValue_;
 3315|    875|                this->allowSeparateLongValue = allowSeparateLongValue_;
 3316|       |
 3317|    875|                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (3317:50): [True: 875, False: 0]
  ------------------
 3318|    875|                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
  ------------------
  |  Branch (3318:51): [True: 875, False: 0]
  ------------------
 3319|    875|            }
_ZNK4args7Command7MatchedEv:
 2187|  13.6k|            { return Base::Matched(); }
_ZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2482|     13|            {
 2483|     13|                if (!Matched())
  ------------------
  |  Branch (2483:21): [True: 0, False: 13]
  ------------------
 2484|      0|                {
 2485|      0|                    return;
 2486|      0|                }
 2487|       |
 2488|     13|                auto onValidationError = [&]
 2489|     13|                {
 2490|     13|                    std::ostringstream problem;
 2491|     13|                    problem << "Group validation failed somewhere!";
 2492|       |#ifdef ARGS_NOEXCEPT
 2493|       |                    error = Error::Validation;
 2494|       |                    errorMsg = problem.str();
 2495|       |#else
 2496|     13|                    throw ValidationError(problem.str());
 2497|     13|#endif
 2498|     13|                };
 2499|       |
 2500|     13|                for (Base *child: Children())
  ------------------
  |  Branch (2500:33): [True: 39, False: 13]
  ------------------
 2501|     39|                {
 2502|     39|                    if (child->IsGroup() && !child->Matched())
  ------------------
  |  Branch (2502:25): [True: 0, False: 39]
  |  Branch (2502:45): [True: 0, False: 0]
  ------------------
 2503|      0|                    {
 2504|      0|                        onValidationError();
 2505|      0|                    }
 2506|       |
 2507|     39|                    child->Validate(shortprefix, longprefix);
 2508|     39|                }
 2509|       |
 2510|     13|                if (subparser != nullptr)
  ------------------
  |  Branch (2510:21): [True: 0, False: 13]
  ------------------
 2511|      0|                {
 2512|      0|                    subparser->Validate(shortprefix, longprefix);
 2513|      0|                    if (!subparser->Matched())
  ------------------
  |  Branch (2513:25): [True: 0, False: 0]
  ------------------
 2514|      0|                    {
 2515|      0|                        onValidationError();
 2516|      0|                    }
 2517|      0|                }
 2518|       |
 2519|     13|                if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
  ------------------
  |  Branch (2519:21): [True: 13, False: 0]
  |  Branch (2519:51): [True: 13, False: 0]
  |  Branch (2519:73): [True: 0, False: 13]
  |  Branch (2519:96): [True: 0, False: 13]
  ------------------
 2520|      0|                {
 2521|      0|                    std::ostringstream problem;
 2522|      0|                    problem << "Command is required";
 2523|       |#ifdef ARGS_NOEXCEPT
 2524|       |                    error = Error::Validation;
 2525|       |                    errorMsg = problem.str();
 2526|       |#else
 2527|      0|                    throw ValidationError(problem.str());
 2528|      0|#endif
 2529|      0|                }
 2530|     13|            }
_ZN4args7Command11GetCommandsEv:
 2385|    875|            {
 2386|    875|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2386:21): [True: 0, False: 875]
  ------------------
 2387|      0|                {
 2388|      0|                    return selectedCommand->GetCommands();
 2389|      0|                }
 2390|       |
 2391|    875|                if (Matched())
  ------------------
  |  Branch (2391:21): [True: 875, False: 0]
  ------------------
 2392|    875|                {
 2393|    875|                    return Group::GetCommands();
 2394|    875|                }
 2395|       |
 2396|      0|                return { this };
 2397|    875|            }
_ZN4args7Command5MatchERKNS_10EitherFlagE:
 2206|  12.5k|            {
 2207|  12.5k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2207:21): [True: 0, False: 12.5k]
  ------------------
 2208|      0|                {
 2209|      0|                    if (auto *res = selectedCommand->Match(flag))
  ------------------
  |  Branch (2209:31): [True: 0, False: 0]
  ------------------
 2210|      0|                    {
 2211|      0|                        return res;
 2212|      0|                    }
 2213|       |
 2214|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (2214:37): [True: 0, False: 0]
  ------------------
 2215|      0|                    {
 2216|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (2216:29): [True: 0, False: 0]
  ------------------
 2217|      0|                        {
 2218|      0|                            if (auto *res = child->Match(flag))
  ------------------
  |  Branch (2218:39): [True: 0, False: 0]
  ------------------
 2219|      0|                            {
 2220|      0|                                return res;
 2221|      0|                            }
 2222|      0|                        }
 2223|      0|                    }
 2224|       |
 2225|      0|                    return nullptr;
 2226|      0|                }
 2227|       |
 2228|  12.5k|                if (subparser != nullptr)
  ------------------
  |  Branch (2228:21): [True: 0, False: 12.5k]
  ------------------
 2229|      0|                {
 2230|      0|                    return subparser->Match(flag);
 2231|      0|                }
 2232|       |
 2233|  12.5k|                return Matched() ? Group::Match(flag) : nullptr;
  ------------------
  |  Branch (2233:24): [True: 12.5k, False: 0]
  ------------------
 2234|  12.5k|            }
_ZN4args7Command17GetNextPositionalEv:
 2270|    195|            {
 2271|    195|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2271:21): [True: 0, False: 195]
  ------------------
 2272|      0|                {
 2273|      0|                    if (auto *res = selectedCommand->GetNextPositional())
  ------------------
  |  Branch (2273:31): [True: 0, False: 0]
  ------------------
 2274|      0|                    {
 2275|      0|                        return res;
 2276|      0|                    }
 2277|       |
 2278|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (2278:37): [True: 0, False: 0]
  ------------------
 2279|      0|                    {
 2280|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (2280:29): [True: 0, False: 0]
  ------------------
 2281|      0|                        {
 2282|      0|                            if (auto *res = child->GetNextPositional())
  ------------------
  |  Branch (2282:39): [True: 0, False: 0]
  ------------------
 2283|      0|                            {
 2284|      0|                                return res;
 2285|      0|                            }
 2286|      0|                        }
 2287|      0|                    }
 2288|       |
 2289|      0|                    return nullptr;
 2290|      0|                }
 2291|       |
 2292|    195|                if (subparser != nullptr)
  ------------------
  |  Branch (2292:21): [True: 0, False: 195]
  ------------------
 2293|      0|                {
 2294|      0|                    return subparser->GetNextPositional();
 2295|      0|                }
 2296|       |
 2297|    195|                return Matched() ? Group::GetNextPositional() : nullptr;
  ------------------
  |  Branch (2297:24): [True: 195, False: 0]
  ------------------
 2298|    195|            }
_ZN4args14ArgumentParser5ResetEv:
 3449|    875|            {
 3450|    875|                Command::Reset();
 3451|    875|                matched = true;
 3452|    875|                readCompletion = false;
 3453|    875|            }
_ZN4args10EitherFlagC2Ec:
  646|  14.6k|        EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
_ZN4args10EitherFlagC2EPKc:
  645|  2.62k|        EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args7MatcherC2ESt16initializer_listINS_10EitherFlagEE:
  751|  2.62k|                Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
_ZN4args10EitherFlag8GetShortESt16initializer_listIS0_E:
  666|  2.62k|        {
  667|  2.62k|            std::unordered_set<char>  shortFlags;
  668|  2.62k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (668:40): [True: 5.25k, False: 2.62k]
  ------------------
  669|  5.25k|            {
  670|  5.25k|                if (flag.isShort)
  ------------------
  |  Branch (670:21): [True: 2.62k, False: 2.62k]
  ------------------
  671|  2.62k|                {
  672|  2.62k|                    shortFlags.insert(flag.shortFlag);
  673|  2.62k|                }
  674|  5.25k|            }
  675|  2.62k|            return shortFlags;
  676|  2.62k|        }
_ZN4args10EitherFlag7GetLongESt16initializer_listIS0_E:
  651|  2.62k|        {
  652|  2.62k|            std::unordered_set<std::string>  longFlags;
  653|  2.62k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (653:40): [True: 5.25k, False: 2.62k]
  ------------------
  654|  5.25k|            {
  655|  5.25k|                if (!flag.isShort)
  ------------------
  |  Branch (655:21): [True: 2.62k, False: 2.62k]
  ------------------
  656|  2.62k|                {
  657|  2.62k|                    longFlags.insert(flag.longFlag);
  658|  2.62k|                }
  659|  5.25k|            }
  660|  2.62k|            return longFlags;
  661|  2.62k|        }
_ZN4args7MatcherC2INSt3__113unordered_setIcNS2_4hashIcEENS2_8equal_toIcEENS2_9allocatorIcEEEENS3_INS2_12basic_stringIcNS2_11char_traitsIcEES9_EENS4_ISE_EENS6_ISE_EENS8_ISE_EEEEEEOT_OT0_:
  735|  2.62k|                Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
  736|  2.62k|            {}
_ZN4args7MatcherC2INSt3__121__hash_const_iteratorIPNS2_11__hash_nodeIcPvEEEENS3_IPNS4_INS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES5_EEEEEET_SI_T0_SJ_:
  710|  2.62k|                shortFlags(shortFlagsStart, shortFlagsEnd),
  711|  2.62k|                longFlags(longFlagsStart, longFlagsEnd)
  712|  2.62k|            {
  713|  2.62k|                if (shortFlags.empty() && longFlags.empty())
  ------------------
  |  Branch (713:21): [True: 0, False: 2.62k]
  |  Branch (713:43): [True: 0, False: 0]
  ------------------
  714|      0|                {
  715|      0|#ifndef ARGS_NOEXCEPT
  716|      0|                    throw UsageError("empty Matcher");
  717|      0|#endif
  718|      0|                }
  719|  2.62k|            }
_ZN4args8HelpFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE:
 3601|    875|            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:
 3566|  2.62k|            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
 3567|  2.62k|            {
 3568|  2.62k|                group_.Add(*this);
 3569|  2.62k|            }
_ZN4args8FlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE:
 1402|  2.62k|            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:
 1251|  2.62k|            NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
_ZN4args9NamedBaseD2Ev:
 1252|  2.62k|            virtual ~NamedBase() {}
_ZN4args7MatcherC2EOS0_:
  753|  2.62k|            Matcher(Matcher &&other) noexcept : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
  754|  2.62k|            {}
_ZN4args5Group3AddERNS_4BaseE:
 1715|  2.62k|            {
 1716|  2.62k|                children.emplace_back(&child);
 1717|  2.62k|            }
_ZN4args8FlagBaseD2Ev:
 1404|  2.62k|            virtual ~FlagBase() {}
_ZN4args4Flag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3590|  11.8k|            {
 3591|  11.8k|            }
_ZNK4args8FlagBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 1438|     39|            {
 1439|     39|                if (!Matched() && IsRequired())
  ------------------
  |  Branch (1439:21): [True: 19, False: 20]
  |  Branch (1439:35): [True: 0, False: 19]
  ------------------
 1440|      0|                {
 1441|      0|                        std::ostringstream problem;
 1442|      0|                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
 1443|       |#ifdef ARGS_NOEXCEPT
 1444|       |                        error = Error::Required;
 1445|       |                        errorMsg = problem.str();
 1446|       |#else
 1447|      0|                        throw RequiredError(problem.str());
 1448|      0|#endif
 1449|      0|                }
 1450|     39|            }
_ZNK4args4Base10IsRequiredEv:
 1104|     19|            {
 1105|     19|                return (GetOptions() & Options::Required) != Options::None;
 1106|     19|            }
_ZN4args10EitherFlagC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  644|    509|        EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args8FlagBase5MatchERKNS_10EitherFlagE:
 1407|  35.4k|            {
 1408|  35.4k|                if (matcher.Match(flag))
  ------------------
  |  Branch (1408:21): [True: 11.8k, False: 23.5k]
  ------------------
 1409|  11.8k|                {
 1410|  11.8k|                    if ((GetOptions() & Options::Single) != Options::None && matched)
  ------------------
  |  Branch (1410:25): [True: 0, False: 11.8k]
  |  Branch (1410:78): [True: 0, False: 0]
  ------------------
 1411|      0|                    {
 1412|      0|                        std::ostringstream problem;
 1413|      0|                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
 1414|       |#ifdef ARGS_NOEXCEPT
 1415|       |                        error = Error::Extra;
 1416|       |                        errorMsg = problem.str();
 1417|       |#else
 1418|      0|                        throw ExtraError(problem.str());
 1419|      0|#endif
 1420|      0|                    }
 1421|  11.8k|                    matched = true;
 1422|  11.8k|                    return this;
 1423|  11.8k|                }
 1424|  23.5k|                return nullptr;
 1425|  35.4k|            }
_ZNK4args7Matcher5MatchERKNS_10EitherFlagE:
  775|  35.4k|            {
  776|  35.4k|                return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
  ------------------
  |  Branch (776:24): [True: 34.0k, False: 1.41k]
  ------------------
  777|  35.4k|            }
_ZNK4args7Matcher5MatchEc:
  761|  34.0k|            {
  762|  34.0k|                return shortFlags.find(flag) != shortFlags.end();
  763|  34.0k|            }
_ZNK4args7Matcher5MatchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  768|  1.41k|            {
  769|  1.41k|                return longFlags.find(flag) != longFlags.end();
  770|  1.41k|            }
_ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  569|    842|            ParseError(const std::string &problem) : Error(problem) {}
_ZN4args5NargsC2Em:
 1063|  11.8k|        Nargs(size_t num_) : min{num_}, max{num_}
 1064|  11.8k|        {
 1065|  11.8k|        }
_ZNK4args9NamedBase4NameEv:
 1300|     20|            {
 1301|     20|                return name;
 1302|     20|            }
_ZNK4args4Flag17NumberOfArgumentsEv:
 3585|  11.8k|            {
 3586|  11.8k|                return 0;
 3587|  11.8k|            }
_ZN4args8HelpFlag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3606|     20|            {
 3607|       |#ifdef ARGS_NOEXCEPT
 3608|       |                    error = Error::Help;
 3609|       |                    errorMsg = Name();
 3610|       |#else
 3611|     20|                    throw Help(Name());
 3612|     20|#endif
 3613|     20|            }
_ZN4args4HelpC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  614|     20|            Help(const std::string &flag) : Error(flag) {}
_ZN4args7MatcherD2Ev:
  756|  5.25k|            ~Matcher() {}
_ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEb:
 3571|  1.75k|            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 (3571:186): [True: 0, False: 1.75k]
  ------------------
 3572|  1.75k|            {
 3573|  1.75k|            }
_ZN4args14ArgumentParser9ParseArgsINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3463|    875|            {
 3464|       |                // Reset all Matched statuses and errors
 3465|    875|                Reset();
 3466|       |#ifdef ARGS_NOEXCEPT
 3467|       |                error = GetError();
 3468|       |                if (error != Error::None)
 3469|       |                {
 3470|       |                    return end;
 3471|       |                }
 3472|       |#endif
 3473|    875|                return Parse(begin, end);
 3474|    875|            }
_ZN4args14ArgumentParser5ParseINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3004|    875|            {
 3005|    875|                bool terminated = false;
 3006|    875|                std::vector<Command *> commands = GetCommands();
 3007|       |
 3008|       |                // Check all arg chunks
 3009|  1.85k|                for (auto it = begin; it != end; ++it)
  ------------------
  |  Branch (3009:39): [True: 1.17k, False: 680]
  ------------------
 3010|  1.17k|                {
 3011|  1.17k|                    if (Complete(it, end))
  ------------------
  |  Branch (3011:25): [True: 0, False: 1.17k]
  ------------------
 3012|      0|                    {
 3013|      0|                        return end;
 3014|      0|                    }
 3015|       |
 3016|  1.17k|                    const auto &chunk = *it;
 3017|       |
 3018|  1.17k|                    if (!terminated && chunk == terminator)
  ------------------
  |  Branch (3018:25): [True: 1.16k, False: 3]
  |  Branch (3018:40): [True: 4, False: 1.16k]
  ------------------
 3019|      4|                    {
 3020|      4|                        terminated = true;
 3021|  1.16k|                    } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
  ------------------
  |  Branch (3021:32): [True: 1.16k, False: 3]
  |  Branch (3021:47): [True: 509, False: 656]
  ------------------
 3022|    509|                    {
 3023|    509|                        if (!ParseLong(it, end))
  ------------------
  |  Branch (3023:29): [True: 0, False: 509]
  ------------------
 3024|      0|                        {
 3025|      0|                            return it;
 3026|      0|                        }
 3027|    659|                    } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
  ------------------
  |  Branch (3027:32): [True: 656, False: 3]
  |  Branch (3027:47): [True: 464, False: 192]
  ------------------
 3028|    464|                    {
 3029|    464|                        if (!ParseShort(it, end))
  ------------------
  |  Branch (3029:29): [True: 0, False: 464]
  ------------------
 3030|      0|                        {
 3031|      0|                            return it;
 3032|      0|                        }
 3033|    464|                    } else if (!terminated && !commands.empty())
  ------------------
  |  Branch (3033:32): [True: 192, False: 3]
  |  Branch (3033:47): [True: 0, False: 192]
  ------------------
 3034|      0|                    {
 3035|      0|                        auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
 3036|      0|                        if (itCommand == commands.end())
  ------------------
  |  Branch (3036:29): [True: 0, False: 0]
  ------------------
 3037|      0|                        {
 3038|      0|                            const std::string errorMessage("Unknown command: " + chunk);
 3039|      0|#ifndef ARGS_NOEXCEPT
 3040|      0|                            throw ParseError(errorMessage);
 3041|       |#else
 3042|       |                            error = Error::Parse;
 3043|       |                            errorMsg = errorMessage;
 3044|       |                            return it;
 3045|       |#endif
 3046|      0|                        }
 3047|       |
 3048|      0|                        SelectCommand(*itCommand);
 3049|       |
 3050|      0|                        if (const auto &coroutine = GetCoroutine())
  ------------------
  |  Branch (3050:41): [True: 0, False: 0]
  ------------------
 3051|      0|                        {
 3052|      0|                            ++it;
 3053|      0|                            RaiiSubparser coro(*this, std::vector<std::string>(it, end));
 3054|      0|                            coroutine(coro.Parser());
 3055|       |#ifdef ARGS_NOEXCEPT
 3056|       |                            error = GetError();
 3057|       |                            if (error != Error::None)
 3058|       |                            {
 3059|       |                                return end;
 3060|       |                            }
 3061|       |
 3062|       |                            if (!coro.Parser().IsParsed())
 3063|       |                            {
 3064|       |                                error = Error::Usage;
 3065|       |                                return end;
 3066|       |                            }
 3067|       |#else
 3068|      0|                            if (!coro.Parser().IsParsed())
  ------------------
  |  Branch (3068:33): [True: 0, False: 0]
  ------------------
 3069|      0|                            {
 3070|      0|                                throw UsageError("Subparser::Parse was not called");
 3071|      0|                            }
 3072|      0|#endif
 3073|       |
 3074|      0|                            break;
 3075|      0|                        }
 3076|       |
 3077|      0|                        commands = GetCommands();
 3078|      0|                    } else
 3079|    195|                    {
 3080|    195|                        auto pos = GetNextPositional();
 3081|    195|                        if (pos)
  ------------------
  |  Branch (3081:29): [True: 0, False: 195]
  ------------------
 3082|      0|                        {
 3083|      0|                            pos->ParseValue(chunk);
 3084|       |
 3085|      0|                            if (pos->KickOut())
  ------------------
  |  Branch (3085:33): [True: 0, False: 0]
  ------------------
 3086|      0|                            {
 3087|      0|                                return ++it;
 3088|      0|                            }
 3089|      0|                        } else
 3090|    195|                        {
 3091|    195|                            const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
 3092|    195|#ifndef ARGS_NOEXCEPT
 3093|    195|                            throw ParseError(errorMessage);
 3094|       |#else
 3095|       |                            error = Error::Parse;
 3096|       |                            errorMsg = errorMessage;
 3097|       |                            return it;
 3098|       |#endif
 3099|    195|                        }
 3100|    195|                    }
 3101|       |
 3102|    977|                    if (!readCompletion && completion != nullptr && completion->Matched())
  ------------------
  |  Branch (3102:25): [True: 310, False: 667]
  |  Branch (3102:44): [True: 0, False: 310]
  |  Branch (3102:69): [True: 0, False: 0]
  ------------------
 3103|      0|                    {
 3104|       |#ifdef ARGS_NOEXCEPT
 3105|       |                        if (completion->GetError() != Error::None)
 3106|       |                        {
 3107|       |                            error = completion->GetError();
 3108|       |                            if (errorMsg.empty())
 3109|       |                            {
 3110|       |                                errorMsg = completion->GetErrorMsg();
 3111|       |                            }
 3112|       |                            return it;
 3113|       |                        }
 3114|       |
 3115|       |                        error = Error::Completion;
 3116|       |#endif
 3117|      0|                        readCompletion = true;
 3118|      0|                        ++it;
 3119|      0|                        const auto argsLeft = static_cast<size_t>(std::distance(it, end));
 3120|      0|                        if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
  ------------------
  |  Branch (3120:29): [True: 0, False: 0]
  |  Branch (3120:55): [True: 0, False: 0]
  |  Branch (3120:72): [True: 0, False: 0]
  ------------------
 3121|      0|                        {
 3122|      0|#ifndef ARGS_NOEXCEPT
 3123|      0|                            throw Completion("");
 3124|       |#else
 3125|       |                            return end;
 3126|       |#endif
 3127|      0|                        }
 3128|       |
 3129|      0|                        ++it;
 3130|      0|                        std::vector<std::string> curArgs;
 3131|      0|                        curArgs.reserve(completion->cword);
 3132|      0|                        auto curIt = it;
 3133|      0|                        for (size_t idx = 0; idx < completion->cword && curIt != end; ++idx, ++curIt)
  ------------------
  |  Branch (3133:46): [True: 0, False: 0]
  |  Branch (3133:73): [True: 0, False: 0]
  ------------------
 3134|      0|                        {
 3135|      0|                            curArgs.push_back(*curIt);
 3136|      0|                        }
 3137|       |
 3138|      0|                        if (completion->syntax == "bash")
  ------------------
  |  Branch (3138:29): [True: 0, False: 0]
  ------------------
 3139|      0|                        {
 3140|       |                            // bash tokenizes --flag=value as --flag=value
 3141|       |                            // Security fix: Use size_t arithmetic throughout to avoid conversion issues
 3142|      0|                            for (size_t idx = 0; idx < curArgs.size(); )
  ------------------
  |  Branch (3142:50): [True: 0, False: 0]
  ------------------
 3143|      0|                            {
 3144|      0|                                if (idx > 0 && curArgs[idx] == "=")
  ------------------
  |  Branch (3144:37): [True: 0, False: 0]
  |  Branch (3144:48): [True: 0, False: 0]
  ------------------
 3145|      0|                                {
 3146|      0|                                    size_t prev_idx = idx - 1;  // Safe since we checked idx > 0
 3147|      0|                                    curArgs[prev_idx] += "=";
 3148|      0|                                    size_t next_idx = 0;
 3149|      0|                                    if (SafeAdd<size_t>(idx, static_cast<size_t>(1), next_idx) && next_idx < curArgs.size())
  ------------------
  |  Branch (3149:41): [True: 0, False: 0]
  |  Branch (3149:99): [True: 0, False: 0]
  ------------------
 3150|      0|                                    {
 3151|      0|                                        curArgs[prev_idx] += curArgs[next_idx];
 3152|       |                                        // Erase the '=' token and the following value token.
 3153|      0|                                        size_t erase_end = 0;
 3154|      0|                                        if (SafeAdd<size_t>(next_idx, static_cast<size_t>(1), erase_end))
  ------------------
  |  Branch (3154:45): [True: 0, False: 0]
  ------------------
 3155|      0|                                        {
 3156|      0|                                            curArgs.erase(curArgs.begin() + idx,
 3157|      0|                                                         curArgs.begin() + erase_end);
 3158|      0|                                        }
 3159|      0|                                    } else
 3160|      0|                                    {
 3161|       |                                        // Safe erase of single '=' token at the end
 3162|      0|                                        curArgs.erase(curArgs.begin() + idx);
 3163|      0|                                    }
 3164|       |                                    // Do not increment idx - next element slides into current position
 3165|      0|                                } else
 3166|      0|                                {
 3167|      0|                                    ++idx;
 3168|      0|                                }
 3169|      0|                            }
 3170|       |
 3171|      0|                        }
 3172|      0|#ifndef ARGS_NOEXCEPT
 3173|      0|                        try
 3174|      0|                        {
 3175|      0|                            Parse(curArgs.begin(), curArgs.end());
 3176|      0|                            throw Completion("");
 3177|      0|                        }
 3178|      0|                        catch (Completion &)
 3179|      0|                        {
 3180|      0|                            throw;
 3181|      0|                        }
 3182|      0|                        catch (args::Error&)
 3183|      0|                        {
 3184|      0|                            throw Completion("");
 3185|      0|                        }
 3186|       |#else
 3187|       |                        return Parse(curArgs.begin(), curArgs.end());
 3188|       |#endif
 3189|      0|                    }
 3190|    977|                }
 3191|       |
 3192|    680|                Validate(shortprefix, longprefix);
 3193|    680|                return end;
 3194|    875|            }
_ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbT_SC_:
 2893|  1.17k|            {
 2894|  1.17k|                auto nextIt = it;
 2895|  1.17k|                if (!readCompletion || (++nextIt != end))
  ------------------
  |  Branch (2895:21): [True: 1.17k, False: 0]
  |  Branch (2895:40): [True: 0, False: 0]
  ------------------
 2896|  1.17k|                {
 2897|  1.17k|                    return false;
 2898|  1.17k|                }
 2899|       |
 2900|      0|                const auto &chunk = *it;
 2901|      0|                auto pos = GetNextPositional();
 2902|      0|                std::vector<Command *> commands = GetCommands();
 2903|      0|                const auto optionType = ParseOption(chunk, true);
 2904|       |
 2905|      0|                if (!commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
  ------------------
  |  Branch (2905:21): [True: 0, False: 0]
  |  Branch (2905:43): [True: 0, False: 0]
  |  Branch (2905:60): [True: 0, False: 0]
  ------------------
 2906|      0|                {
 2907|      0|                    for (auto &cmd : commands)
  ------------------
  |  Branch (2907:36): [True: 0, False: 0]
  ------------------
 2908|      0|                    {
 2909|      0|                        if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (2909:29): [True: 0, False: 0]
  ------------------
 2910|      0|                        {
 2911|      0|                            AddCompletionReply(chunk, cmd->Name());
 2912|      0|                        }
 2913|      0|                    }
 2914|      0|                } else
 2915|      0|                {
 2916|      0|                    bool hasPositionalCompletion = true;
 2917|       |
 2918|      0|                    if (!commands.empty())
  ------------------
  |  Branch (2918:25): [True: 0, False: 0]
  ------------------
 2919|      0|                    {
 2920|      0|                        for (auto &cmd : commands)
  ------------------
  |  Branch (2920:40): [True: 0, False: 0]
  ------------------
 2921|      0|                        {
 2922|      0|                            if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (2922:33): [True: 0, False: 0]
  ------------------
 2923|      0|                            {
 2924|      0|                                AddCompletionReply(chunk, cmd->Name());
 2925|      0|                            }
 2926|      0|                        }
 2927|      0|                    } else if (pos)
  ------------------
  |  Branch (2927:32): [True: 0, False: 0]
  ------------------
 2928|      0|                    {
 2929|      0|                        if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (2929:29): [True: 0, False: 0]
  ------------------
 2930|      0|                        {
 2931|      0|                            auto choices = pos->HelpChoices(helpParams);
 2932|      0|                            hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
  ------------------
  |  Branch (2932:55): [True: 0, False: 0]
  |  Branch (2932:75): [True: 0, False: 0]
  ------------------
 2933|      0|                            for (auto &choice : choices)
  ------------------
  |  Branch (2933:47): [True: 0, False: 0]
  ------------------
 2934|      0|                            {
 2935|      0|                                AddCompletionReply(chunk, choice);
 2936|      0|                            }
 2937|      0|                        }
 2938|      0|                    }
 2939|       |
 2940|      0|                    if (hasPositionalCompletion)
  ------------------
  |  Branch (2940:25): [True: 0, False: 0]
  ------------------
 2941|      0|                    {
 2942|      0|                        auto flags = GetAllFlags();
 2943|      0|                        for (auto flag : flags)
  ------------------
  |  Branch (2943:40): [True: 0, False: 0]
  ------------------
 2944|      0|                        {
 2945|      0|                            if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
  ------------------
  |  Branch (2945:33): [True: 0, False: 0]
  ------------------
 2946|      0|                            {
 2947|      0|                                continue;
 2948|      0|                            }
 2949|       |
 2950|      0|                            auto &matcher = flag->GetMatcher();
 2951|      0|                            if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
  ------------------
  |  Branch (2951:33): [True: 0, False: 0]
  ------------------
 2952|      0|                            {
 2953|      0|                                for (auto &flagName : matcher.GetFlagStrings())
  ------------------
  |  Branch (2953:53): [True: 0, False: 0]
  ------------------
 2954|      0|                                {
 2955|      0|                                    if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
  ------------------
  |  Branch (2955:41): [True: 0, False: 0]
  ------------------
 2956|      0|                                    {
 2957|      0|                                        break;
 2958|      0|                                    }
 2959|      0|                                }
 2960|      0|                            }
 2961|      0|                        }
 2962|       |
 2963|      0|                        if (optionType == OptionType::LongFlag && allowJoinedLongValue)
  ------------------
  |  Branch (2963:29): [True: 0, False: 0]
  |  Branch (2963:67): [True: 0, False: 0]
  ------------------
 2964|      0|                        {
 2965|      0|                            const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
  ------------------
  |  Branch (2965:52): [True: 0, False: 0]
  ------------------
 2966|      0|                            if (separator != chunk.npos)
  ------------------
  |  Branch (2966:33): [True: 0, False: 0]
  ------------------
 2967|      0|                            {
 2968|      0|                                std::string arg(chunk, 0, separator);
 2969|      0|                                if (auto flag = this->Match(arg.substr(longprefix.size())))
  ------------------
  |  Branch (2969:42): [True: 0, False: 0]
  ------------------
 2970|      0|                                {
 2971|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (2971:55): [True: 0, False: 0]
  ------------------
 2972|      0|                                    {
 2973|      0|                                        AddCompletionReply(chunk, arg + longseparator + choice);
 2974|      0|                                    }
 2975|      0|                                }
 2976|      0|                            }
 2977|      0|                        } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
  ------------------
  |  Branch (2977:36): [True: 0, False: 0]
  |  Branch (2977:75): [True: 0, False: 0]
  ------------------
 2978|      0|                        {
 2979|      0|                            if (chunk.size() > shortprefix.size() + 1)
  ------------------
  |  Branch (2979:33): [True: 0, False: 0]
  ------------------
 2980|      0|                            {
 2981|      0|                                auto arg = chunk.at(shortprefix.size());
 2982|       |                                //TODO: support -abcVALUE where a and b take no value
 2983|      0|                                if (auto flag = this->Match(arg))
  ------------------
  |  Branch (2983:42): [True: 0, False: 0]
  ------------------
 2984|      0|                                {
 2985|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (2985:55): [True: 0, False: 0]
  ------------------
 2986|      0|                                    {
 2987|      0|                                        AddCompletionReply(chunk, shortprefix + arg + choice);
 2988|      0|                                    }
 2989|      0|                                }
 2990|      0|                            }
 2991|      0|                        }
 2992|      0|                    }
 2993|      0|                }
 2994|       |
 2995|      0|#ifndef ARGS_NOEXCEPT
 2996|      0|                throw Completion(completion->Get());
 2997|       |#else
 2998|       |                return true;
 2999|       |#endif
 3000|  1.17k|            }
_ZN4args14ArgumentParser11ParseOptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 2601|  1.82k|            {
 2602|  1.82k|                if (s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()))
  ------------------
  |  Branch (2602:21): [True: 509, False: 1.31k]
  |  Branch (2602:49): [True: 0, False: 509]
  |  Branch (2602:63): [True: 509, False: 0]
  ------------------
 2603|    509|                {
 2604|    509|                    return OptionType::LongFlag;
 2605|    509|                }
 2606|       |
 2607|  1.31k|                if (s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()))
  ------------------
  |  Branch (2607:21): [True: 938, False: 374]
  |  Branch (2607:50): [True: 0, False: 938]
  |  Branch (2607:64): [True: 928, False: 10]
  ------------------
 2608|    928|                {
 2609|    928|                    return OptionType::ShortFlag;
 2610|    928|                }
 2611|       |
 2612|    384|                return OptionType::Positional;
 2613|  1.31k|            }
_ZN4args14ArgumentParser9ParseLongINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2721|    509|            {
 2722|    509|                const auto &chunk = *it;
 2723|    509|                const auto argchunk = chunk.substr(longprefix.size());
 2724|       |                // Try to separate it, in case of a separator:
 2725|    509|                const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
  ------------------
  |  Branch (2725:40): [True: 0, False: 509]
  ------------------
 2726|       |                // If the separator is in the argument, separate it.
 2727|    509|                const auto arg = (separator != argchunk.npos ?
  ------------------
  |  Branch (2727:35): [True: 235, False: 274]
  ------------------
 2728|    235|                    std::string(argchunk, 0, separator)
 2729|    509|                    : argchunk);
 2730|    509|                const auto joined = (separator != argchunk.npos ?
  ------------------
  |  Branch (2730:38): [True: 235, False: 274]
  ------------------
 2731|    235|                    argchunk.substr(separator + longseparator.size())
 2732|    509|                    : std::string());
 2733|       |
 2734|    509|                if (auto flag = Match(arg))
  ------------------
  |  Branch (2734:26): [True: 103, False: 406]
  ------------------
 2735|    103|                {
 2736|       |#ifdef ARGS_NOEXCEPT
 2737|       |                    // Match() may set the flag's error (e.g. Error::Extra when
 2738|       |                    // Options::Single is violated). In non-noexcept mode that
 2739|       |                    // path throws and parsing stops before the value is read;
 2740|       |                    // in noexcept mode we must mirror that and skip the value
 2741|       |                    // parsing so the previously-stored value is preserved.
 2742|       |                    if (flag->GetError() != Error::None)
 2743|       |                    {
 2744|       |                        return false;
 2745|       |                    }
 2746|       |#endif
 2747|    103|                    std::vector<std::string> values;
 2748|    103|                    const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
 2749|    103|                                                                     separator != argchunk.npos, joined, false, values);
 2750|    103|                    if (!errorMessage.empty())
  ------------------
  |  Branch (2750:25): [True: 20, False: 83]
  ------------------
 2751|     20|                    {
 2752|     20|#ifndef ARGS_NOEXCEPT
 2753|     20|                        throw ParseError(errorMessage);
 2754|       |#else
 2755|       |                        error = Error::Parse;
 2756|       |                        errorMsg = errorMessage;
 2757|       |                        return false;
 2758|       |#endif
 2759|     20|                    }
 2760|       |
 2761|     83|                    if (!readCompletion)
  ------------------
  |  Branch (2761:25): [True: 83, False: 0]
  ------------------
 2762|     83|                    {
 2763|     83|                        flag->ParseValue(values);
 2764|       |#ifdef ARGS_NOEXCEPT
 2765|       |                        // Non-noexcept ParseValue paths throw on Help, reader
 2766|       |                        // failure, or Map miss, which halts parsing. Mirror
 2767|       |                        // that here so a later parser-level error (e.g. an
 2768|       |                        // unknown flag) cannot shadow the flag's error in
 2769|       |                        // ArgumentParser::GetError().
 2770|       |                        if (flag->GetError() != Error::None)
 2771|       |                        {
 2772|       |                            return false;
 2773|       |                        }
 2774|       |#endif
 2775|     83|                    }
 2776|       |
 2777|     83|                    if (flag->KickOut())
  ------------------
  |  Branch (2777:25): [True: 0, False: 83]
  ------------------
 2778|      0|                    {
 2779|      0|                        ++it;
 2780|      0|                        return false;
 2781|      0|                    }
 2782|     83|                } else
 2783|    406|                {
 2784|    406|                    const std::string errorMessage("Flag could not be matched: " + arg);
 2785|    406|#ifndef ARGS_NOEXCEPT
 2786|    406|                    throw ParseError(errorMessage);
 2787|       |#else
 2788|       |                    error = Error::Parse;
 2789|       |                    errorMsg = errorMessage;
 2790|       |                    return false;
 2791|       |#endif
 2792|    406|                }
 2793|       |
 2794|     83|                return true;
 2795|    509|            }
_ZN4args14ArgumentParser15ParseArgsValuesINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_RNS_8FlagBaseERKS9_RT_SG_bbbSF_bRNS2_6vectorIS9_NS7_IS9_EEEE:
 2651|  11.8k|            {
 2652|  11.8k|                values.clear();
 2653|       |
 2654|  11.8k|                Nargs nargs = flag.NumberOfArguments();
 2655|       |
 2656|  11.8k|                if (hasJoined && !allowJoined && nargs.min != 0)
  ------------------
  |  Branch (2656:21): [True: 11.5k, False: 309]
  |  Branch (2656:34): [True: 0, False: 11.5k]
  |  Branch (2656:50): [True: 0, False: 0]
  ------------------
 2657|      0|                {
 2658|      0|                    return "Flag '" + arg + "' was passed a joined argument, but these are disallowed";
 2659|      0|                }
 2660|       |
 2661|  11.8k|                if (hasJoined)
  ------------------
  |  Branch (2661:21): [True: 11.5k, False: 309]
  ------------------
 2662|  11.5k|                {
 2663|  11.5k|                    if (!canDiscardJoined || nargs.max != 0)
  ------------------
  |  Branch (2663:25): [True: 20, False: 11.5k]
  |  Branch (2663:46): [True: 0, False: 11.5k]
  ------------------
 2664|     20|                    {
 2665|     20|                        values.push_back(joinedArg);
 2666|     20|                    }
 2667|  11.5k|                } else if (!allowSeparate)
  ------------------
  |  Branch (2667:28): [True: 0, False: 309]
  ------------------
 2668|      0|                {
 2669|      0|                    if (nargs.min != 0)
  ------------------
  |  Branch (2669:25): [True: 0, False: 0]
  ------------------
 2670|      0|                    {
 2671|      0|                        return "Flag '" + arg + "' was passed a separate argument, but these are disallowed";
 2672|      0|                    }
 2673|      0|                } else
 2674|    309|                {
 2675|    309|                    auto valueIt = it;
 2676|    309|                    ++valueIt;
 2677|       |
 2678|    309|                    while (valueIt != end &&
  ------------------
  |  Branch (2678:28): [True: 297, False: 12]
  ------------------
 2679|    297|                           values.size() < nargs.max &&
  ------------------
  |  Branch (2679:28): [True: 0, False: 297]
  ------------------
 2680|      0|                           (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional))
  ------------------
  |  Branch (2680:29): [True: 0, False: 0]
  |  Branch (2680:58): [True: 0, False: 0]
  ------------------
 2681|      0|                    {
 2682|      0|                        if (Complete(flag, valueIt, end))
  ------------------
  |  Branch (2682:29): [True: 0, False: 0]
  ------------------
 2683|      0|                        {
 2684|      0|                            it = end;
 2685|      0|                            return "";
 2686|      0|                        }
 2687|       |
 2688|      0|                        values.push_back(*valueIt);
 2689|      0|                        ++it;
 2690|      0|                        ++valueIt;
 2691|      0|                    }
 2692|    309|                }
 2693|       |
 2694|  11.8k|                if (values.size() > nargs.max)
  ------------------
  |  Branch (2694:21): [True: 20, False: 11.8k]
  ------------------
 2695|     20|                {
 2696|     20|                    return "Passed an argument into a non-argument flag: " + arg;
 2697|  11.8k|                } else if (values.size() < nargs.min)
  ------------------
  |  Branch (2697:28): [True: 0, False: 11.8k]
  ------------------
 2698|      0|                {
 2699|      0|                    if (nargs.min == 1 && nargs.max == 1)
  ------------------
  |  Branch (2699:25): [True: 0, False: 0]
  |  Branch (2699:43): [True: 0, False: 0]
  ------------------
 2700|      0|                    {
 2701|      0|                        return "Flag '" + arg + "' requires an argument but received none";
 2702|      0|                    } else if (nargs.min == 1)
  ------------------
  |  Branch (2702:32): [True: 0, False: 0]
  ------------------
 2703|      0|                    {
 2704|      0|                        return "Flag '" + arg + "' requires at least one argument but received none";
 2705|      0|                    } else if (nargs.min != nargs.max)
  ------------------
  |  Branch (2705:32): [True: 0, False: 0]
  ------------------
 2706|      0|                    {
 2707|      0|                        return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
 2708|      0|                               " arguments but received " + std::to_string(values.size());
 2709|      0|                    } else
 2710|      0|                    {
 2711|      0|                        return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
 2712|      0|                               " arguments but received " + std::to_string(values.size());
 2713|      0|                    }
 2714|      0|                }
 2715|       |
 2716|  11.8k|                return {};
 2717|  11.8k|            }
_ZN4args14ArgumentParser10ParseShortINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2799|    464|            {
 2800|    464|                const auto &chunk = *it;
 2801|    464|                const auto argchunk = chunk.substr(shortprefix.size());
 2802|  12.2k|                for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
  ------------------
  |  Branch (2802:57): [True: 12.0k, False: 243]
  ------------------
 2803|  12.0k|                {
 2804|  12.0k|                    const auto arg = *argit;
 2805|       |
 2806|  12.0k|                    if (auto flag = Match(arg))
  ------------------
  |  Branch (2806:30): [True: 11.7k, False: 221]
  ------------------
 2807|  11.7k|                    {
 2808|       |#ifdef ARGS_NOEXCEPT
 2809|       |                        // See ParseLong: if Match recorded an error
 2810|       |                        // (e.g. Options::Single violation), bail before the
 2811|       |                        // value is parsed so the prior value is preserved.
 2812|       |                        if (flag->GetError() != Error::None)
 2813|       |                        {
 2814|       |                            return false;
 2815|       |                        }
 2816|       |#endif
 2817|  11.7k|                        const std::string value(argit + 1, std::end(argchunk));
 2818|  11.7k|                        std::vector<std::string> values;
 2819|  11.7k|                        const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
 2820|  11.7k|                                                                         allowSeparateShortValue, allowJoinedShortValue,
 2821|  11.7k|                                                                         !value.empty(), value, !value.empty(), values);
 2822|       |
 2823|  11.7k|                        if (!errorMessage.empty())
  ------------------
  |  Branch (2823:29): [True: 0, False: 11.7k]
  ------------------
 2824|      0|                        {
 2825|      0|#ifndef ARGS_NOEXCEPT
 2826|      0|                            throw ParseError(errorMessage);
 2827|       |#else
 2828|       |                            error = Error::Parse;
 2829|       |                            errorMsg = errorMessage;
 2830|       |                            return false;
 2831|       |#endif
 2832|      0|                        }
 2833|       |
 2834|  11.7k|                        if (!readCompletion)
  ------------------
  |  Branch (2834:29): [True: 11.7k, False: 0]
  ------------------
 2835|  11.7k|                        {
 2836|  11.7k|                            flag->ParseValue(values);
 2837|       |#ifdef ARGS_NOEXCEPT
 2838|       |                            // See ParseLong: ensure a flag-level error from
 2839|       |                            // ParseValue (Help, Parse, Map) halts parsing so
 2840|       |                            // it cannot be shadowed by a later parser error.
 2841|       |                            if (flag->GetError() != Error::None)
 2842|       |                            {
 2843|       |                                return false;
 2844|       |                            }
 2845|       |#endif
 2846|  11.7k|                        }
 2847|       |
 2848|  11.7k|                        if (flag->KickOut())
  ------------------
  |  Branch (2848:29): [True: 0, False: 11.7k]
  ------------------
 2849|      0|                        {
 2850|      0|                            ++it;
 2851|      0|                            return false;
 2852|      0|                        }
 2853|       |
 2854|  11.7k|                        if (!values.empty())
  ------------------
  |  Branch (2854:29): [True: 0, False: 11.7k]
  ------------------
 2855|      0|                        {
 2856|      0|                            break;
 2857|      0|                        }
 2858|  11.7k|                    } else
 2859|    221|                    {
 2860|    221|                        const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
 2861|    221|#ifndef ARGS_NOEXCEPT
 2862|    221|                        throw ParseError(errorMessage);
 2863|       |#else
 2864|       |                        error = Error::Parse;
 2865|       |                        errorMsg = errorMessage;
 2866|       |                        return false;
 2867|       |#endif
 2868|    221|                    }
 2869|  12.0k|                }
 2870|       |
 2871|    243|                return true;
 2872|    464|            }
_ZNK4args4Base7KickOutEv:
 1190|  11.8k|            {
 1191|  11.8k|                return (options & Options::KickOut) != Options::None;
 1192|  11.8k|            }

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