_ZN4args14ArgumentParserC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2831|    904|            {
 2832|    904|                Description(description_);
 2833|    904|                Epilog(epilog_);
 2834|    904|                LongPrefix("--");
 2835|    904|                ShortPrefix("-");
 2836|    904|                LongSeparator("=");
 2837|    904|                Terminator("--");
 2838|    904|                SetArgumentSeparations(true, true, true, true);
 2839|    904|                matched = true;
 2840|    904|            }
_ZN4args7CommandC2Ev:
 1779|    904|            Command() = default;
_ZN4args5GroupC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_8functionIFbRKS0_EEENS_7OptionsE:
 1402|    904|            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:
  809|  3.61k|            Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
_ZNK4args4Base7MatchedEv:
  823|  10.1k|            {
  824|  10.1k|                return matched;
  825|  10.1k|            }
_ZN4args4Base11GetCommandsEv:
  845|  2.71k|            {
  846|  2.71k|                return {};
  847|  2.71k|            }
_ZNK4args4Base7IsGroupEv:
  850|     45|            {
  851|     45|                return false;
  852|     45|            }
_ZN4args4Base17GetNextPositionalEv:
  860|    513|            {
  861|    513|                return nullptr;
  862|    513|            }
_ZNK4args4Base10HasCommandEv:
  880|     45|            {
  881|     45|                return false;
  882|     45|            }
_ZN4args4Base5ResetEv:
  909|  3.61k|            {
  910|  3.61k|                matched = false;
  911|       |#ifdef ARGS_NOEXCEPT
  912|       |                error = Error::None;
  913|       |                errorMsg.clear();
  914|       |#endif
  915|  3.61k|            }
_ZN4args4BaseD2Ev:
  810|  3.61k|            virtual ~Base() {}
_ZN4args5GroupD2Ev:
 1408|    904|            virtual ~Group() {}
_ZNK4args5Group8ChildrenEv:
 1420|  11.0k|            {
 1421|  11.0k|                return children;
 1422|  11.0k|            }
_ZN4argsanENS_7OptionsES0_:
  594|  16.5k|    {
  595|  16.5k|        return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
  596|  16.5k|    }
_ZNK4args4Base10GetOptionsEv:
  813|  8.31k|            {
  814|  8.31k|                return options;
  815|  8.31k|            }
_ZN4args5Group11GetCommandsEv:
 1578|    904|            {
 1579|    904|                std::vector<Command*> res;
 1580|    904|                for (const auto &child : Children())
  ------------------
  |  Branch (1580:40): [True: 2.71k, False: 904]
  ------------------
 1581|  2.71k|                {
 1582|  2.71k|                    auto subparsers = child->GetCommands();
 1583|  2.71k|                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
 1584|  2.71k|                }
 1585|    904|                return res;
 1586|    904|            }
_ZN4args5Group5MatchERKNS_10EitherFlagE:
 1430|  8.98k|            {
 1431|  8.98k|                for (Base *child: Children())
  ------------------
  |  Branch (1431:33): [True: 23.7k, False: 695]
  ------------------
 1432|  23.7k|                {
 1433|  23.7k|                    if (FlagBase *match = child->Match(flag))
  ------------------
  |  Branch (1433:35): [True: 8.29k, False: 15.4k]
  ------------------
 1434|  8.29k|                    {
 1435|  8.29k|                        return match;
 1436|  8.29k|                    }
 1437|  23.7k|                }
 1438|    695|                return nullptr;
 1439|  8.98k|            }
_ZN4args5Group17GetNextPositionalEv:
 1465|    171|            {
 1466|    171|                for (Base *child: Children())
  ------------------
  |  Branch (1466:33): [True: 513, False: 171]
  ------------------
 1467|    513|                {
 1468|    513|                    if (auto next = child->GetNextPositional())
  ------------------
  |  Branch (1468:30): [True: 0, False: 513]
  ------------------
 1469|      0|                    {
 1470|      0|                        return next;
 1471|      0|                    }
 1472|    513|                }
 1473|    171|                return nullptr;
 1474|    171|            }
_ZNK4args5Group10HasCommandEv:
 1499|     15|            {
 1500|     15|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
 1501|     15|            }
_ZZNK4args5Group10HasCommandEvENKUlPNS_4BaseEE_clES2_:
 1500|     45|                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
_ZN4args5Group5ResetEv:
 1594|    904|            {
 1595|    904|                Base::Reset();
 1596|       |
 1597|    904|                for (auto &child: Children())
  ------------------
  |  Branch (1597:33): [True: 2.71k, False: 904]
  ------------------
 1598|  2.71k|                {
 1599|  2.71k|                    child->Reset();
 1600|  2.71k|                }
 1601|       |#ifdef ARGS_NOEXCEPT
 1602|       |                error = Error::None;
 1603|       |                errorMsg.clear();
 1604|       |#endif
 1605|    904|            }
_ZN4args7Command5ResetEv:
 2231|    904|            {
 2232|    904|                Group::Reset();
 2233|    904|                selectedCommand = nullptr;
 2234|    904|                subparserProgramLine.clear();
 2235|    904|                subparserDescription.clear();
 2236|    904|                subparserHasFlag = false;
 2237|    904|                subparserHasPositional = false;
 2238|    904|                subparserHasCommand = false;
 2239|       |#ifdef ARGS_NOEXCEPT
 2240|       |                subparserError = Error::None;
 2241|       |#endif
 2242|    904|            }
_ZN4args7Command11DescriptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1852|    904|            { this->description = description_; }
_ZN4args7Command6EpilogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1862|    904|            { this->epilog = epilog_; }
_ZN4args14ArgumentParser10LongPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2864|    904|            {
 2865|    904|                this->longprefix = longprefix_;
 2866|    904|                this->helpParams.longPrefix = longprefix_;
 2867|    904|            }
_ZN4args14ArgumentParser11ShortPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2876|    904|            {
 2877|    904|                this->shortprefix = shortprefix_;
 2878|    904|                this->helpParams.shortPrefix = shortprefix_;
 2879|    904|            }
_ZN4args14ArgumentParser13LongSeparatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2888|    904|            {
 2889|    904|                if (longseparator_.empty())
  ------------------
  |  Branch (2889:21): [True: 0, False: 904]
  ------------------
 2890|      0|                {
 2891|      0|                    const std::string errorMessage("longseparator can not be set to empty");
 2892|       |#ifdef ARGS_NOEXCEPT
 2893|       |                    error = Error::Usage;
 2894|       |                    errorMsg = errorMessage;
 2895|       |#else
 2896|      0|                    throw UsageError(errorMessage);
 2897|      0|#endif
 2898|      0|                } else
 2899|    904|                {
 2900|    904|                    this->longseparator = longseparator_;
 2901|    904|                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator_ : " ";
  ------------------
  |  Branch (2901:54): [True: 904, False: 0]
  ------------------
 2902|    904|                }
 2903|    904|            }
_ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  265|    889|            Error(const std::string &problem) : std::runtime_error(problem) {}
_ZN4args14ArgumentParser10TerminatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2912|    904|            { this->terminator = terminator_; }
_ZN4args14ArgumentParser22SetArgumentSeparationsEbbbb:
 2942|    904|            {
 2943|    904|                this->allowJoinedShortValue = allowJoinedShortValue_;
 2944|    904|                this->allowJoinedLongValue = allowJoinedLongValue_;
 2945|    904|                this->allowSeparateShortValue = allowSeparateShortValue_;
 2946|    904|                this->allowSeparateLongValue = allowSeparateLongValue_;
 2947|       |
 2948|    904|                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
  ------------------
  |  Branch (2948:50): [True: 904, False: 0]
  ------------------
 2949|    904|                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
  ------------------
  |  Branch (2949:51): [True: 904, False: 0]
  ------------------
 2950|    904|            }
_ZNK4args7Command7MatchedEv:
 1885|  10.0k|            { return Base::Matched(); }
_ZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2180|     15|            {
 2181|     15|                if (!Matched())
  ------------------
  |  Branch (2181:21): [True: 0, False: 15]
  ------------------
 2182|      0|                {
 2183|      0|                    return;
 2184|      0|                }
 2185|       |
 2186|     15|                auto onValidationError = [&]
 2187|     15|                {
 2188|     15|                    std::ostringstream problem;
 2189|     15|                    problem << "Group validation failed somewhere!";
 2190|       |#ifdef ARGS_NOEXCEPT
 2191|       |                    error = Error::Validation;
 2192|       |                    errorMsg = problem.str();
 2193|       |#else
 2194|     15|                    throw ValidationError(problem.str());
 2195|     15|#endif
 2196|     15|                };
 2197|       |
 2198|     15|                for (Base *child: Children())
  ------------------
  |  Branch (2198:33): [True: 45, False: 15]
  ------------------
 2199|     45|                {
 2200|     45|                    if (child->IsGroup() && !child->Matched())
  ------------------
  |  Branch (2200:25): [True: 0, False: 45]
  |  Branch (2200:45): [True: 0, False: 0]
  ------------------
 2201|      0|                    {
 2202|      0|                        onValidationError();
 2203|      0|                    }
 2204|       |
 2205|     45|                    child->Validate(shortprefix, longprefix);
 2206|     45|                }
 2207|       |
 2208|     15|                if (subparser != nullptr)
  ------------------
  |  Branch (2208:21): [True: 0, False: 15]
  ------------------
 2209|      0|                {
 2210|      0|                    subparser->Validate(shortprefix, longprefix);
 2211|      0|                    if (!subparser->Matched())
  ------------------
  |  Branch (2211:25): [True: 0, False: 0]
  ------------------
 2212|      0|                    {
 2213|      0|                        onValidationError();
 2214|      0|                    }
 2215|      0|                }
 2216|       |
 2217|     15|                if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
  ------------------
  |  Branch (2217:21): [True: 15, False: 0]
  |  Branch (2217:51): [True: 15, False: 0]
  |  Branch (2217:73): [True: 0, False: 15]
  |  Branch (2217:96): [True: 0, False: 15]
  ------------------
 2218|      0|                {
 2219|      0|                    std::ostringstream problem;
 2220|      0|                    problem << "Command is required";
 2221|       |#ifdef ARGS_NOEXCEPT
 2222|       |                    error = Error::Validation;
 2223|       |                    errorMsg = problem.str();
 2224|       |#else
 2225|      0|                    throw ValidationError(problem.str());
 2226|      0|#endif
 2227|      0|                }
 2228|     15|            }
_ZN4args7Command11GetCommandsEv:
 2083|    904|            {
 2084|    904|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (2084:21): [True: 0, False: 904]
  ------------------
 2085|      0|                {
 2086|      0|                    return selectedCommand->GetCommands();
 2087|      0|                }
 2088|       |
 2089|    904|                if (Matched())
  ------------------
  |  Branch (2089:21): [True: 904, False: 0]
  ------------------
 2090|    904|                {
 2091|    904|                    return Group::GetCommands();
 2092|    904|                }
 2093|       |
 2094|      0|                return { this };
 2095|    904|            }
_ZN4args7Command5MatchERKNS_10EitherFlagE:
 1904|  8.98k|            {
 1905|  8.98k|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (1905:21): [True: 0, False: 8.98k]
  ------------------
 1906|      0|                {
 1907|      0|                    if (auto *res = selectedCommand->Match(flag))
  ------------------
  |  Branch (1907:31): [True: 0, False: 0]
  ------------------
 1908|      0|                    {
 1909|      0|                        return res;
 1910|      0|                    }
 1911|       |
 1912|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (1912:37): [True: 0, False: 0]
  ------------------
 1913|      0|                    {
 1914|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (1914:29): [True: 0, False: 0]
  ------------------
 1915|      0|                        {
 1916|      0|                            if (auto *res = child->Match(flag))
  ------------------
  |  Branch (1916:39): [True: 0, False: 0]
  ------------------
 1917|      0|                            {
 1918|      0|                                return res;
 1919|      0|                            }
 1920|      0|                        }
 1921|      0|                    }
 1922|       |
 1923|      0|                    return nullptr;
 1924|      0|                }
 1925|       |
 1926|  8.98k|                if (subparser != nullptr)
  ------------------
  |  Branch (1926:21): [True: 0, False: 8.98k]
  ------------------
 1927|      0|                {
 1928|      0|                    return subparser->Match(flag);
 1929|      0|                }
 1930|       |
 1931|  8.98k|                return Matched() ? Group::Match(flag) : nullptr;
  ------------------
  |  Branch (1931:24): [True: 8.98k, False: 0]
  ------------------
 1932|  8.98k|            }
_ZN4args7Command17GetNextPositionalEv:
 1968|    171|            {
 1969|    171|                if (selectedCommand != nullptr)
  ------------------
  |  Branch (1969:21): [True: 0, False: 171]
  ------------------
 1970|      0|                {
 1971|      0|                    if (auto *res = selectedCommand->GetNextPositional())
  ------------------
  |  Branch (1971:31): [True: 0, False: 0]
  ------------------
 1972|      0|                    {
 1973|      0|                        return res;
 1974|      0|                    }
 1975|       |
 1976|      0|                    for (auto *child: Children())
  ------------------
  |  Branch (1976:37): [True: 0, False: 0]
  ------------------
 1977|      0|                    {
 1978|      0|                        if ((child->GetOptions() & Options::Global) != Options::None)
  ------------------
  |  Branch (1978:29): [True: 0, False: 0]
  ------------------
 1979|      0|                        {
 1980|      0|                            if (auto *res = child->GetNextPositional())
  ------------------
  |  Branch (1980:39): [True: 0, False: 0]
  ------------------
 1981|      0|                            {
 1982|      0|                                return res;
 1983|      0|                            }
 1984|      0|                        }
 1985|      0|                    }
 1986|       |
 1987|      0|                    return nullptr;
 1988|      0|                }
 1989|       |
 1990|    171|                if (subparser != nullptr)
  ------------------
  |  Branch (1990:21): [True: 0, False: 171]
  ------------------
 1991|      0|                {
 1992|      0|                    return subparser->GetNextPositional();
 1993|      0|                }
 1994|       |
 1995|    171|                return Matched() ? Group::GetNextPositional() : nullptr;
  ------------------
  |  Branch (1995:24): [True: 171, False: 0]
  ------------------
 1996|    171|            }
_ZN4args14ArgumentParser5ResetEv:
 3068|    904|            {
 3069|    904|                Command::Reset();
 3070|    904|                matched = true;
 3071|    904|                readCompletion = false;
 3072|    904|            }
_ZN4args10EitherFlagC2Ec:
  360|  11.1k|        EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
_ZN4args10EitherFlagC2EPKc:
  359|  2.71k|        EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args7MatcherC2ESt16initializer_listINS_10EitherFlagEE:
  465|  2.71k|                Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
_ZN4args10EitherFlag8GetShortESt16initializer_listIS0_E:
  380|  2.71k|        {
  381|  2.71k|            std::unordered_set<char>  shortFlags;
  382|  2.71k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (382:40): [True: 5.42k, False: 2.71k]
  ------------------
  383|  5.42k|            {
  384|  5.42k|                if (flag.isShort)
  ------------------
  |  Branch (384:21): [True: 2.71k, False: 2.71k]
  ------------------
  385|  2.71k|                {
  386|  2.71k|                    shortFlags.insert(flag.shortFlag);
  387|  2.71k|                }
  388|  5.42k|            }
  389|  2.71k|            return shortFlags;
  390|  2.71k|        }
_ZN4args10EitherFlag7GetLongESt16initializer_listIS0_E:
  365|  2.71k|        {
  366|  2.71k|            std::unordered_set<std::string>  longFlags;
  367|  2.71k|            for (const EitherFlag &flag: flags)
  ------------------
  |  Branch (367:40): [True: 5.42k, False: 2.71k]
  ------------------
  368|  5.42k|            {
  369|  5.42k|                if (!flag.isShort)
  ------------------
  |  Branch (369:21): [True: 2.71k, False: 2.71k]
  ------------------
  370|  2.71k|                {
  371|  2.71k|                    longFlags.insert(flag.longFlag);
  372|  2.71k|                }
  373|  5.42k|            }
  374|  2.71k|            return longFlags;
  375|  2.71k|        }
_ZN4args7MatcherC2INSt3__113unordered_setIcNS2_4hashIcEENS2_8equal_toIcEENS2_9allocatorIcEEEENS3_INS2_12basic_stringIcNS2_11char_traitsIcEES9_EENS4_ISE_EENS6_ISE_EENS8_ISE_EEEEEEOT_OT0_:
  449|  2.71k|                Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
  450|  2.71k|            {}
_ZN4args7MatcherC2INSt3__121__hash_const_iteratorIPNS2_11__hash_nodeIcPvEEEENS3_IPNS4_INS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES5_EEEEEET_SI_T0_SJ_:
  424|  2.71k|                shortFlags(shortFlagsStart, shortFlagsEnd),
  425|  2.71k|                longFlags(longFlagsStart, longFlagsEnd)
  426|  2.71k|            {
  427|  2.71k|                if (shortFlags.empty() && longFlags.empty())
  ------------------
  |  Branch (427:21): [True: 0, False: 2.71k]
  |  Branch (427:43): [True: 0, False: 0]
  ------------------
  428|      0|                {
  429|      0|#ifndef ARGS_NOEXCEPT
  430|      0|                    throw UsageError("empty Matcher");
  431|      0|#endif
  432|      0|                }
  433|  2.71k|            }
_ZN4args8HelpFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE:
 3214|    904|            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:
 3179|  2.71k|            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
 3180|  2.71k|            {
 3181|  2.71k|                group_.Add(*this);
 3182|  2.71k|            }
_ZN4args8FlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE:
 1116|  2.71k|            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:
  965|  2.71k|            NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
_ZN4args9NamedBaseD2Ev:
  966|  2.71k|            virtual ~NamedBase() {}
_ZN4args7MatcherC2EOS0_:
  467|  2.71k|            Matcher(Matcher &&other) noexcept : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
  468|  2.71k|            {}
_ZN4args5Group3AddERNS_4BaseE:
 1413|  2.71k|            {
 1414|  2.71k|                children.emplace_back(&child);
 1415|  2.71k|            }
_ZN4args8FlagBaseD2Ev:
 1118|  2.71k|            virtual ~FlagBase() {}
_ZN4args4Flag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3203|  8.27k|            {
 3204|  8.27k|            }
_ZNK4args8FlagBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 1152|     45|            {
 1153|     45|                if (!Matched() && IsRequired())
  ------------------
  |  Branch (1153:21): [True: 22, False: 23]
  |  Branch (1153:35): [True: 0, False: 22]
  ------------------
 1154|      0|                {
 1155|      0|                        std::ostringstream problem;
 1156|      0|                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
 1157|       |#ifdef ARGS_NOEXCEPT
 1158|       |                        error = Error::Required;
 1159|       |                        errorMsg = problem.str();
 1160|       |#else
 1161|      0|                        throw RequiredError(problem.str());
 1162|      0|#endif
 1163|      0|                }
 1164|     45|            }
_ZNK4args4Base10IsRequiredEv:
  818|     22|            {
  819|     22|                return (GetOptions() & Options::Required) != Options::None;
  820|     22|            }
_ZN4args10EitherFlagC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  358|    539|        EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
_ZN4args8FlagBase5MatchERKNS_10EitherFlagE:
 1121|  23.7k|            {
 1122|  23.7k|                if (matcher.Match(flag))
  ------------------
  |  Branch (1122:21): [True: 8.29k, False: 15.4k]
  ------------------
 1123|  8.29k|                {
 1124|  8.29k|                    if ((GetOptions() & Options::Single) != Options::None && matched)
  ------------------
  |  Branch (1124:25): [True: 0, False: 8.29k]
  |  Branch (1124:78): [True: 0, False: 0]
  ------------------
 1125|      0|                    {
 1126|      0|                        std::ostringstream problem;
 1127|      0|                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
 1128|       |#ifdef ARGS_NOEXCEPT
 1129|       |                        error = Error::Extra;
 1130|       |                        errorMsg = problem.str();
 1131|       |#else
 1132|      0|                        throw ExtraError(problem.str());
 1133|      0|#endif
 1134|      0|                    }
 1135|  8.29k|                    matched = true;
 1136|  8.29k|                    return this;
 1137|  8.29k|                }
 1138|  15.4k|                return nullptr;
 1139|  23.7k|            }
_ZNK4args7Matcher5MatchERKNS_10EitherFlagE:
  489|  23.7k|            {
  490|  23.7k|                return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
  ------------------
  |  Branch (490:24): [True: 22.2k, False: 1.53k]
  ------------------
  491|  23.7k|            }
_ZNK4args7Matcher5MatchEc:
  475|  22.2k|            {
  476|  22.2k|                return shortFlags.find(flag) != shortFlags.end();
  477|  22.2k|            }
_ZNK4args7Matcher5MatchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  482|  1.53k|            {
  483|  1.53k|                return longFlags.find(flag) != longFlags.end();
  484|  1.53k|            }
_ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  283|    874|            ParseError(const std::string &problem) : Error(problem) {}
_ZN4args5NargsC2Em:
  777|  8.29k|        Nargs(size_t num_) : min{num_}, max{num_}
  778|  8.29k|        {
  779|  8.29k|        }
_ZNK4args9NamedBase4NameEv:
 1014|     15|            {
 1015|     15|                return name;
 1016|     15|            }
_ZNK4args4Flag17NumberOfArgumentsEv:
 3198|  8.29k|            {
 3199|  8.29k|                return 0;
 3200|  8.29k|            }
_ZN4args8HelpFlag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
 3219|     15|            {
 3220|       |#ifdef ARGS_NOEXCEPT
 3221|       |                    error = Error::Help;
 3222|       |                    errorMsg = Name();
 3223|       |#else
 3224|     15|                    throw Help(Name());
 3225|     15|#endif
 3226|     15|            }
_ZN4args4HelpC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  328|     15|            Help(const std::string &flag) : Error(flag) {}
_ZN4args7MatcherD2Ev:
  470|  5.42k|            ~Matcher() {}
_ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEb:
 3184|  1.80k|            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 (3184:186): [True: 0, False: 1.80k]
  ------------------
 3185|  1.80k|            {
 3186|  1.80k|            }
_ZN4args14ArgumentParser9ParseArgsINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 3082|    904|            {
 3083|       |                // Reset all Matched statuses and errors
 3084|    904|                Reset();
 3085|       |#ifdef ARGS_NOEXCEPT
 3086|       |                error = GetError();
 3087|       |                if (error != Error::None)
 3088|       |                {
 3089|       |                    return end;
 3090|       |                }
 3091|       |#endif
 3092|    904|                return Parse(begin, end);
 3093|    904|            }
_ZN4args14ArgumentParser5ParseINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SC_SC_:
 2662|    904|            {
 2663|    904|                bool terminated = false;
 2664|    904|                std::vector<Command *> commands = GetCommands();
 2665|       |
 2666|       |                // Check all arg chunks
 2667|  1.92k|                for (auto it = begin; it != end; ++it)
  ------------------
  |  Branch (2667:39): [True: 1.18k, False: 733]
  ------------------
 2668|  1.18k|                {
 2669|  1.18k|                    if (Complete(it, end))
  ------------------
  |  Branch (2669:25): [True: 0, False: 1.18k]
  ------------------
 2670|      0|                    {
 2671|      0|                        return end;
 2672|      0|                    }
 2673|       |
 2674|  1.18k|                    const auto &chunk = *it;
 2675|       |
 2676|  1.18k|                    if (!terminated && chunk == terminator)
  ------------------
  |  Branch (2676:25): [True: 1.18k, False: 1]
  |  Branch (2676:40): [True: 2, False: 1.18k]
  ------------------
 2677|      2|                    {
 2678|      2|                        terminated = true;
 2679|  1.18k|                    } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
  ------------------
  |  Branch (2679:32): [True: 1.18k, False: 1]
  |  Branch (2679:47): [True: 539, False: 646]
  ------------------
 2680|    539|                    {
 2681|    539|                        if (!ParseLong(it, end))
  ------------------
  |  Branch (2681:29): [True: 0, False: 539]
  ------------------
 2682|      0|                        {
 2683|      0|                            return it;
 2684|      0|                        }
 2685|    647|                    } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
  ------------------
  |  Branch (2685:32): [True: 646, False: 1]
  |  Branch (2685:47): [True: 476, False: 170]
  ------------------
 2686|    476|                    {
 2687|    476|                        if (!ParseShort(it, end))
  ------------------
  |  Branch (2687:29): [True: 0, False: 476]
  ------------------
 2688|      0|                        {
 2689|      0|                            return it;
 2690|      0|                        }
 2691|    476|                    } else if (!terminated && !commands.empty())
  ------------------
  |  Branch (2691:32): [True: 170, False: 1]
  |  Branch (2691:47): [True: 0, False: 170]
  ------------------
 2692|      0|                    {
 2693|      0|                        auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
 2694|      0|                        if (itCommand == commands.end())
  ------------------
  |  Branch (2694:29): [True: 0, False: 0]
  ------------------
 2695|      0|                        {
 2696|      0|                            const std::string errorMessage("Unknown command: " + chunk);
 2697|      0|#ifndef ARGS_NOEXCEPT
 2698|      0|                            throw ParseError(errorMessage);
 2699|       |#else
 2700|       |                            error = Error::Parse;
 2701|       |                            errorMsg = errorMessage;
 2702|       |                            return it;
 2703|       |#endif
 2704|      0|                        }
 2705|       |
 2706|      0|                        SelectCommand(*itCommand);
 2707|       |
 2708|      0|                        if (const auto &coroutine = GetCoroutine())
  ------------------
  |  Branch (2708:41): [True: 0, False: 0]
  ------------------
 2709|      0|                        {
 2710|      0|                            ++it;
 2711|      0|                            RaiiSubparser coro(*this, std::vector<std::string>(it, end));
 2712|      0|                            coroutine(coro.Parser());
 2713|       |#ifdef ARGS_NOEXCEPT
 2714|       |                            error = GetError();
 2715|       |                            if (error != Error::None)
 2716|       |                            {
 2717|       |                                return end;
 2718|       |                            }
 2719|       |
 2720|       |                            if (!coro.Parser().IsParsed())
 2721|       |                            {
 2722|       |                                error = Error::Usage;
 2723|       |                                return end;
 2724|       |                            }
 2725|       |#else
 2726|      0|                            if (!coro.Parser().IsParsed())
  ------------------
  |  Branch (2726:33): [True: 0, False: 0]
  ------------------
 2727|      0|                            {
 2728|      0|                                throw UsageError("Subparser::Parse was not called");
 2729|      0|                            }
 2730|      0|#endif
 2731|       |
 2732|      0|                            break;
 2733|      0|                        }
 2734|       |
 2735|      0|                        commands = GetCommands();
 2736|      0|                    } else
 2737|    171|                    {
 2738|    171|                        auto pos = GetNextPositional();
 2739|    171|                        if (pos)
  ------------------
  |  Branch (2739:29): [True: 0, False: 171]
  ------------------
 2740|      0|                        {
 2741|      0|                            pos->ParseValue(chunk);
 2742|       |
 2743|      0|                            if (pos->KickOut())
  ------------------
  |  Branch (2743:33): [True: 0, False: 0]
  ------------------
 2744|      0|                            {
 2745|      0|                                return ++it;
 2746|      0|                            }
 2747|      0|                        } else
 2748|    171|                        {
 2749|    171|                            const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
 2750|    171|#ifndef ARGS_NOEXCEPT
 2751|    171|                            throw ParseError(errorMessage);
 2752|       |#else
 2753|       |                            error = Error::Parse;
 2754|       |                            errorMsg = errorMessage;
 2755|       |                            return it;
 2756|       |#endif
 2757|    171|                        }
 2758|    171|                    }
 2759|       |
 2760|  1.01k|                    if (!readCompletion && completion != nullptr && completion->Matched())
  ------------------
  |  Branch (2760:25): [True: 299, False: 718]
  |  Branch (2760:44): [True: 0, False: 299]
  |  Branch (2760:69): [True: 0, False: 0]
  ------------------
 2761|      0|                    {
 2762|       |#ifdef ARGS_NOEXCEPT
 2763|       |                        error = Error::Completion;
 2764|       |#endif
 2765|      0|                        readCompletion = true;
 2766|      0|                        ++it;
 2767|      0|                        const auto argsLeft = static_cast<size_t>(std::distance(it, end));
 2768|      0|                        if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
  ------------------
  |  Branch (2768:29): [True: 0, False: 0]
  |  Branch (2768:55): [True: 0, False: 0]
  |  Branch (2768:72): [True: 0, False: 0]
  ------------------
 2769|      0|                        {
 2770|      0|#ifndef ARGS_NOEXCEPT
 2771|      0|                            throw Completion("");
 2772|      0|#endif
 2773|      0|                        }
 2774|       |
 2775|      0|                        std::vector<std::string> curArgs(++it, end);
 2776|      0|                        curArgs.resize(completion->cword);
 2777|       |
 2778|      0|                        if (completion->syntax == "bash")
  ------------------
  |  Branch (2778:29): [True: 0, False: 0]
  ------------------
 2779|      0|                        {
 2780|       |                            // bash tokenizes --flag=value as --flag=value
 2781|      0|                            for (size_t idx = 0; idx < curArgs.size(); )
  ------------------
  |  Branch (2781:50): [True: 0, False: 0]
  ------------------
 2782|      0|                            {
 2783|      0|                                if (idx > 0 && curArgs[idx] == "=")
  ------------------
  |  Branch (2783:37): [True: 0, False: 0]
  |  Branch (2783:48): [True: 0, False: 0]
  ------------------
 2784|      0|                                {
 2785|      0|                                    curArgs[idx - 1] += "=";
 2786|       |                                    // Avoid warnings from -Wsign-conversion
 2787|      0|                                    const auto signedIdx = static_cast<std::ptrdiff_t>(idx);
 2788|      0|                                    if (idx + 1 < curArgs.size())
  ------------------
  |  Branch (2788:41): [True: 0, False: 0]
  ------------------
 2789|      0|                                    {
 2790|      0|                                        curArgs[idx - 1] += curArgs[idx + 1];
 2791|      0|                                        curArgs.erase(curArgs.begin() + signedIdx, curArgs.begin() + signedIdx + 2);
 2792|      0|                                    } else
 2793|      0|                                    {
 2794|      0|                                        curArgs.erase(curArgs.begin() + signedIdx);
 2795|      0|                                    }
 2796|      0|                                } else
 2797|      0|                                {
 2798|      0|                                    ++idx;
 2799|      0|                                }
 2800|      0|                            }
 2801|       |
 2802|      0|                        }
 2803|      0|#ifndef ARGS_NOEXCEPT
 2804|      0|                        try
 2805|      0|                        {
 2806|      0|                            Parse(curArgs.begin(), curArgs.end());
 2807|      0|                            throw Completion("");
 2808|      0|                        }
 2809|      0|                        catch (Completion &)
 2810|      0|                        {
 2811|      0|                            throw;
 2812|      0|                        }
 2813|      0|                        catch (args::Error&)
 2814|      0|                        {
 2815|      0|                            throw Completion("");
 2816|      0|                        }
 2817|       |#else
 2818|       |                        return Parse(curArgs.begin(), curArgs.end());
 2819|       |#endif
 2820|      0|                    }
 2821|  1.01k|                }
 2822|       |
 2823|    733|                Validate(shortprefix, longprefix);
 2824|    733|                return end;
 2825|    904|            }
_ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbT_SC_:
 2551|  1.18k|            {
 2552|  1.18k|                auto nextIt = it;
 2553|  1.18k|                if (!readCompletion || (++nextIt != end))
  ------------------
  |  Branch (2553:21): [True: 1.18k, False: 0]
  |  Branch (2553:40): [True: 0, False: 0]
  ------------------
 2554|  1.18k|                {
 2555|  1.18k|                    return false;
 2556|  1.18k|                }
 2557|       |
 2558|      0|                const auto &chunk = *it;
 2559|      0|                auto pos = GetNextPositional();
 2560|      0|                std::vector<Command *> commands = GetCommands();
 2561|      0|                const auto optionType = ParseOption(chunk, true);
 2562|       |
 2563|      0|                if (!commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
  ------------------
  |  Branch (2563:21): [True: 0, False: 0]
  |  Branch (2563:43): [True: 0, False: 0]
  |  Branch (2563:60): [True: 0, False: 0]
  ------------------
 2564|      0|                {
 2565|      0|                    for (auto &cmd : commands)
  ------------------
  |  Branch (2565:36): [True: 0, False: 0]
  ------------------
 2566|      0|                    {
 2567|      0|                        if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (2567:29): [True: 0, False: 0]
  ------------------
 2568|      0|                        {
 2569|      0|                            AddCompletionReply(chunk, cmd->Name());
 2570|      0|                        }
 2571|      0|                    }
 2572|      0|                } else
 2573|      0|                {
 2574|      0|                    bool hasPositionalCompletion = true;
 2575|       |
 2576|      0|                    if (!commands.empty())
  ------------------
  |  Branch (2576:25): [True: 0, False: 0]
  ------------------
 2577|      0|                    {
 2578|      0|                        for (auto &cmd : commands)
  ------------------
  |  Branch (2578:40): [True: 0, False: 0]
  ------------------
 2579|      0|                        {
 2580|      0|                            if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (2580:33): [True: 0, False: 0]
  ------------------
 2581|      0|                            {
 2582|      0|                                AddCompletionReply(chunk, cmd->Name());
 2583|      0|                            }
 2584|      0|                        }
 2585|      0|                    } else if (pos)
  ------------------
  |  Branch (2585:32): [True: 0, False: 0]
  ------------------
 2586|      0|                    {
 2587|      0|                        if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
  ------------------
  |  Branch (2587:29): [True: 0, False: 0]
  ------------------
 2588|      0|                        {
 2589|      0|                            auto choices = pos->HelpChoices(helpParams);
 2590|      0|                            hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
  ------------------
  |  Branch (2590:55): [True: 0, False: 0]
  |  Branch (2590:75): [True: 0, False: 0]
  ------------------
 2591|      0|                            for (auto &choice : choices)
  ------------------
  |  Branch (2591:47): [True: 0, False: 0]
  ------------------
 2592|      0|                            {
 2593|      0|                                AddCompletionReply(chunk, choice);
 2594|      0|                            }
 2595|      0|                        }
 2596|      0|                    }
 2597|       |
 2598|      0|                    if (hasPositionalCompletion)
  ------------------
  |  Branch (2598:25): [True: 0, False: 0]
  ------------------
 2599|      0|                    {
 2600|      0|                        auto flags = GetAllFlags();
 2601|      0|                        for (auto flag : flags)
  ------------------
  |  Branch (2601:40): [True: 0, False: 0]
  ------------------
 2602|      0|                        {
 2603|      0|                            if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
  ------------------
  |  Branch (2603:33): [True: 0, False: 0]
  ------------------
 2604|      0|                            {
 2605|      0|                                continue;
 2606|      0|                            }
 2607|       |
 2608|      0|                            auto &matcher = flag->GetMatcher();
 2609|      0|                            if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
  ------------------
  |  Branch (2609:33): [True: 0, False: 0]
  ------------------
 2610|      0|                            {
 2611|      0|                                for (auto &flagName : matcher.GetFlagStrings())
  ------------------
  |  Branch (2611:53): [True: 0, False: 0]
  ------------------
 2612|      0|                                {
 2613|      0|                                    if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
  ------------------
  |  Branch (2613:41): [True: 0, False: 0]
  ------------------
 2614|      0|                                    {
 2615|      0|                                        break;
 2616|      0|                                    }
 2617|      0|                                }
 2618|      0|                            }
 2619|      0|                        }
 2620|       |
 2621|      0|                        if (optionType == OptionType::LongFlag && allowJoinedLongValue)
  ------------------
  |  Branch (2621:29): [True: 0, False: 0]
  |  Branch (2621:67): [True: 0, False: 0]
  ------------------
 2622|      0|                        {
 2623|      0|                            const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
  ------------------
  |  Branch (2623:52): [True: 0, False: 0]
  ------------------
 2624|      0|                            if (separator != chunk.npos)
  ------------------
  |  Branch (2624:33): [True: 0, False: 0]
  ------------------
 2625|      0|                            {
 2626|      0|                                std::string arg(chunk, 0, separator);
 2627|      0|                                if (auto flag = this->Match(arg.substr(longprefix.size())))
  ------------------
  |  Branch (2627:42): [True: 0, False: 0]
  ------------------
 2628|      0|                                {
 2629|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (2629:55): [True: 0, False: 0]
  ------------------
 2630|      0|                                    {
 2631|      0|                                        AddCompletionReply(chunk, arg + longseparator + choice);
 2632|      0|                                    }
 2633|      0|                                }
 2634|      0|                            }
 2635|      0|                        } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
  ------------------
  |  Branch (2635:36): [True: 0, False: 0]
  |  Branch (2635:75): [True: 0, False: 0]
  ------------------
 2636|      0|                        {
 2637|      0|                            if (chunk.size() > shortprefix.size() + 1)
  ------------------
  |  Branch (2637:33): [True: 0, False: 0]
  ------------------
 2638|      0|                            {
 2639|      0|                                auto arg = chunk.at(shortprefix.size());
 2640|       |                                //TODO: support -abcVALUE where a and b take no value
 2641|      0|                                if (auto flag = this->Match(arg))
  ------------------
  |  Branch (2641:42): [True: 0, False: 0]
  ------------------
 2642|      0|                                {
 2643|      0|                                    for (auto &choice : flag->HelpChoices(helpParams))
  ------------------
  |  Branch (2643:55): [True: 0, False: 0]
  ------------------
 2644|      0|                                    {
 2645|      0|                                        AddCompletionReply(chunk, shortprefix + arg + choice);
 2646|      0|                                    }
 2647|      0|                                }
 2648|      0|                            }
 2649|      0|                        }
 2650|      0|                    }
 2651|      0|                }
 2652|       |
 2653|      0|#ifndef ARGS_NOEXCEPT
 2654|      0|                throw Completion(completion->Get());
 2655|       |#else
 2656|       |                return true;
 2657|       |#endif
 2658|  1.18k|            }
_ZN4args14ArgumentParser11ParseOptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 2299|  1.83k|            {
 2300|  1.83k|                if (s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()))
  ------------------
  |  Branch (2300:21): [True: 539, False: 1.29k]
  |  Branch (2300:49): [True: 0, False: 539]
  |  Branch (2300:63): [True: 539, False: 0]
  ------------------
 2301|    539|                {
 2302|    539|                    return OptionType::LongFlag;
 2303|    539|                }
 2304|       |
 2305|  1.29k|                if (s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()))
  ------------------
  |  Branch (2305:21): [True: 962, False: 330]
  |  Branch (2305:50): [True: 0, False: 962]
  |  Branch (2305:64): [True: 952, False: 10]
  ------------------
 2306|    952|                {
 2307|    952|                    return OptionType::ShortFlag;
 2308|    952|                }
 2309|       |
 2310|    340|                return OptionType::Positional;
 2311|  1.29k|            }
_ZN4args14ArgumentParser9ParseLongINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2419|    539|            {
 2420|    539|                const auto &chunk = *it;
 2421|    539|                const auto argchunk = chunk.substr(longprefix.size());
 2422|       |                // Try to separate it, in case of a separator:
 2423|    539|                const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
  ------------------
  |  Branch (2423:40): [True: 0, False: 539]
  ------------------
 2424|       |                // If the separator is in the argument, separate it.
 2425|    539|                const auto arg = (separator != argchunk.npos ?
  ------------------
  |  Branch (2425:35): [True: 221, False: 318]
  ------------------
 2426|    221|                    std::string(argchunk, 0, separator)
 2427|    539|                    : argchunk);
 2428|    539|                const auto joined = (separator != argchunk.npos ?
  ------------------
  |  Branch (2428:38): [True: 221, False: 318]
  ------------------
 2429|    221|                    argchunk.substr(separator + longseparator.size())
 2430|    539|                    : std::string());
 2431|       |
 2432|    539|                if (auto flag = Match(arg))
  ------------------
  |  Branch (2432:26): [True: 80, False: 459]
  ------------------
 2433|     80|                {
 2434|     80|                    std::vector<std::string> values;
 2435|     80|                    const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
 2436|     80|                                                                     separator != argchunk.npos, joined, false, values);
 2437|     80|                    if (!errorMessage.empty())
  ------------------
  |  Branch (2437:25): [True: 8, False: 72]
  ------------------
 2438|      8|                    {
 2439|      8|#ifndef ARGS_NOEXCEPT
 2440|      8|                        throw ParseError(errorMessage);
 2441|       |#else
 2442|       |                        error = Error::Parse;
 2443|       |                        errorMsg = errorMessage;
 2444|       |                        return false;
 2445|       |#endif
 2446|      8|                    }
 2447|       |
 2448|     72|                    if (!readCompletion)
  ------------------
  |  Branch (2448:25): [True: 72, False: 0]
  ------------------
 2449|     72|                    {
 2450|     72|                        flag->ParseValue(values);
 2451|     72|                    }
 2452|       |
 2453|     72|                    if (flag->KickOut())
  ------------------
  |  Branch (2453:25): [True: 0, False: 72]
  ------------------
 2454|      0|                    {
 2455|      0|                        ++it;
 2456|      0|                        return false;
 2457|      0|                    }
 2458|     72|                } else
 2459|    459|                {
 2460|    459|                    const std::string errorMessage("Flag could not be matched: " + arg);
 2461|    459|#ifndef ARGS_NOEXCEPT
 2462|    459|                    throw ParseError(errorMessage);
 2463|       |#else
 2464|       |                    error = Error::Parse;
 2465|       |                    errorMsg = errorMessage;
 2466|       |                    return false;
 2467|       |#endif
 2468|    459|                }
 2469|       |
 2470|     72|                return true;
 2471|    539|            }
_ZN4args14ArgumentParser15ParseArgsValuesINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_RNS_8FlagBaseERKS9_RT_SG_bbbSF_bRNS2_6vectorIS9_NS7_IS9_EEEE:
 2349|  8.29k|            {
 2350|  8.29k|                values.clear();
 2351|       |
 2352|  8.29k|                Nargs nargs = flag.NumberOfArguments();
 2353|       |
 2354|  8.29k|                if (hasJoined && !allowJoined && nargs.min != 0)
  ------------------
  |  Branch (2354:21): [True: 7.99k, False: 299]
  |  Branch (2354:34): [True: 0, False: 7.99k]
  |  Branch (2354:50): [True: 0, False: 0]
  ------------------
 2355|      0|                {
 2356|      0|                    return "Flag '" + arg + "' was passed a joined argument, but these are disallowed";
 2357|      0|                }
 2358|       |
 2359|  8.29k|                if (hasJoined)
  ------------------
  |  Branch (2359:21): [True: 7.99k, False: 299]
  ------------------
 2360|  7.99k|                {
 2361|  7.99k|                    if (!canDiscardJoined || nargs.max != 0)
  ------------------
  |  Branch (2361:25): [True: 8, False: 7.98k]
  |  Branch (2361:46): [True: 0, False: 7.98k]
  ------------------
 2362|      8|                    {
 2363|      8|                        values.push_back(joinedArg);
 2364|      8|                    }
 2365|  7.99k|                } else if (!allowSeparate)
  ------------------
  |  Branch (2365:28): [True: 0, False: 299]
  ------------------
 2366|      0|                {
 2367|      0|                    if (nargs.min != 0)
  ------------------
  |  Branch (2367:25): [True: 0, False: 0]
  ------------------
 2368|      0|                    {
 2369|      0|                        return "Flag '" + arg + "' was passed a separate argument, but these are disallowed";
 2370|      0|                    }
 2371|      0|                } else
 2372|    299|                {
 2373|    299|                    auto valueIt = it;
 2374|    299|                    ++valueIt;
 2375|       |
 2376|    299|                    while (valueIt != end &&
  ------------------
  |  Branch (2376:28): [True: 284, False: 15]
  ------------------
 2377|    299|                           values.size() < nargs.max &&
  ------------------
  |  Branch (2377:28): [True: 0, False: 284]
  ------------------
 2378|    299|                           (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional))
  ------------------
  |  Branch (2378:29): [True: 0, False: 0]
  |  Branch (2378:58): [True: 0, False: 0]
  ------------------
 2379|      0|                    {
 2380|      0|                        if (Complete(flag, valueIt, end))
  ------------------
  |  Branch (2380:29): [True: 0, False: 0]
  ------------------
 2381|      0|                        {
 2382|      0|                            it = end;
 2383|      0|                            return "";
 2384|      0|                        }
 2385|       |
 2386|      0|                        values.push_back(*valueIt);
 2387|      0|                        ++it;
 2388|      0|                        ++valueIt;
 2389|      0|                    }
 2390|    299|                }
 2391|       |
 2392|  8.29k|                if (values.size() > nargs.max)
  ------------------
  |  Branch (2392:21): [True: 8, False: 8.28k]
  ------------------
 2393|      8|                {
 2394|      8|                    return "Passed an argument into a non-argument flag: " + arg;
 2395|  8.28k|                } else if (values.size() < nargs.min)
  ------------------
  |  Branch (2395:28): [True: 0, False: 8.28k]
  ------------------
 2396|      0|                {
 2397|      0|                    if (nargs.min == 1 && nargs.max == 1)
  ------------------
  |  Branch (2397:25): [True: 0, False: 0]
  |  Branch (2397:43): [True: 0, False: 0]
  ------------------
 2398|      0|                    {
 2399|      0|                        return "Flag '" + arg + "' requires an argument but received none";
 2400|      0|                    } else if (nargs.min == 1)
  ------------------
  |  Branch (2400:32): [True: 0, False: 0]
  ------------------
 2401|      0|                    {
 2402|      0|                        return "Flag '" + arg + "' requires at least one argument but received none";
 2403|      0|                    } else if (nargs.min != nargs.max)
  ------------------
  |  Branch (2403:32): [True: 0, False: 0]
  ------------------
 2404|      0|                    {
 2405|      0|                        return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
 2406|      0|                               " arguments but received " + std::to_string(values.size());
 2407|      0|                    } else
 2408|      0|                    {
 2409|      0|                        return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
 2410|      0|                               " arguments but received " + std::to_string(values.size());
 2411|      0|                    }
 2412|      0|                }
 2413|       |
 2414|  8.28k|                return {};
 2415|  8.29k|            }
_ZN4args14ArgumentParser10ParseShortINSt3__111__wrap_iterIPNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SC_:
 2475|    476|            {
 2476|    476|                const auto &chunk = *it;
 2477|    476|                const auto argchunk = chunk.substr(shortprefix.size());
 2478|  8.69k|                for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
  ------------------
  |  Branch (2478:57): [True: 8.45k, False: 240]
  ------------------
 2479|  8.45k|                {
 2480|  8.45k|                    const auto arg = *argit;
 2481|       |
 2482|  8.45k|                    if (auto flag = Match(arg))
  ------------------
  |  Branch (2482:30): [True: 8.21k, False: 236]
  ------------------
 2483|  8.21k|                    {
 2484|  8.21k|                        const std::string value(argit + 1, std::end(argchunk));
 2485|  8.21k|                        std::vector<std::string> values;
 2486|  8.21k|                        const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
 2487|  8.21k|                                                                         allowSeparateShortValue, allowJoinedShortValue,
 2488|  8.21k|                                                                         !value.empty(), value, !value.empty(), values);
 2489|       |
 2490|  8.21k|                        if (!errorMessage.empty())
  ------------------
  |  Branch (2490:29): [True: 0, False: 8.21k]
  ------------------
 2491|      0|                        {
 2492|      0|#ifndef ARGS_NOEXCEPT
 2493|      0|                            throw ParseError(errorMessage);
 2494|       |#else
 2495|       |                            error = Error::Parse;
 2496|       |                            errorMsg = errorMessage;
 2497|       |                            return false;
 2498|       |#endif
 2499|      0|                        }
 2500|       |
 2501|  8.21k|                        if (!readCompletion)
  ------------------
  |  Branch (2501:29): [True: 8.21k, False: 0]
  ------------------
 2502|  8.21k|                        {
 2503|  8.21k|                            flag->ParseValue(values);
 2504|  8.21k|                        }
 2505|       |
 2506|  8.21k|                        if (flag->KickOut())
  ------------------
  |  Branch (2506:29): [True: 0, False: 8.21k]
  ------------------
 2507|      0|                        {
 2508|      0|                            ++it;
 2509|      0|                            return false;
 2510|      0|                        }
 2511|       |
 2512|  8.21k|                        if (!values.empty())
  ------------------
  |  Branch (2512:29): [True: 0, False: 8.21k]
  ------------------
 2513|      0|                        {
 2514|      0|                            break;
 2515|      0|                        }
 2516|  8.21k|                    } else
 2517|    236|                    {
 2518|    236|                        const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
 2519|    236|#ifndef ARGS_NOEXCEPT
 2520|    236|                        throw ParseError(errorMessage);
 2521|       |#else
 2522|       |                        error = Error::Parse;
 2523|       |                        errorMsg = errorMessage;
 2524|       |                        return false;
 2525|       |#endif
 2526|    236|                    }
 2527|  8.45k|                }
 2528|       |
 2529|    240|                return true;
 2530|    476|            }
_ZNK4args4Base7KickOutEv:
  904|  8.27k|            {
  905|  8.27k|                return (options & Options::KickOut) != Options::None;
  906|  8.27k|            }

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