_ZN8usbguard14stringToNumberIhEET_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEi:
  298|   140k|  {
  299|   140k|    const unsigned int num = stringToNumber<unsigned int>(s, base);
  300|   140k|    return (uint8_t)num;
  301|   140k|  }

_ZN8usbguard11make_uniqueINS_11RulePrivateEJEEENSt3__110unique_ptrIT_NS2_14default_deleteIS4_EEEEDpOT0_:
  260|   107k|  {
  261|   107k|    return std::unique_ptr<T>(new T(std::forward<Params>(params)...));
  262|   107k|  }
_ZN8usbguard14tokenizeStringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRKT_RNS1_6vectorIS8_NS5_IS8_EEEENSD_10value_typeEb:
   71|   837k|  {
   72|   837k|    typename StringType::size_type pos, last_pos = 0;
   73|       |
   74|  1.78M|    while (true) {
  ------------------
  |  Branch (74:12): [Folded - Ignored]
  ------------------
   75|  1.78M|      pos = str.find_first_of(delimiters, last_pos);
   76|       |
   77|  1.78M|      if (pos == StringType::npos) {
  ------------------
  |  Branch (77:11): [True: 837k, False: 948k]
  ------------------
   78|   837k|        pos = str.length();
   79|       |
   80|   837k|        if (pos != last_pos || !trim_empty) {
  ------------------
  |  Branch (80:13): [True: 837k, False: 0]
  |  Branch (80:32): [True: 0, False: 0]
  ------------------
   81|   837k|          tokens.push_back(StringType(str.data() + last_pos, pos - last_pos));
   82|   837k|        }
   83|       |
   84|   837k|        break;
   85|   837k|      }
   86|   948k|      else {
   87|   948k|        if (pos != last_pos || !trim_empty) {
  ------------------
  |  Branch (87:13): [True: 948k, False: 0]
  |  Branch (87:32): [True: 0, False: 0]
  ------------------
   88|   948k|          tokens.push_back(StringType(str.data() + last_pos, pos - last_pos));
   89|   948k|        }
   90|   948k|      }
   91|       |
   92|   948k|      last_pos = pos + 1;
   93|   948k|    }
   94|   837k|  }
_ZN8usbguard14stringToNumberIjEET_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEi:
  133|   140k|  {
  134|   140k|    std::istringstream ss(s);
  135|   140k|    T num;
  136|   140k|    ss >> std::setbase(base) >> num;
  137|   140k|    return num;
  138|   140k|  }

_ZN8usbguard23AllowedMatchesConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   33|  29.9k|  {
   34|  29.9k|    _device_match_rule = parseRuleFromString(std::string("allow ") + device_spec);
   35|  29.9k|    _interface_ptr = nullptr;
   36|  29.9k|  }
_ZN8usbguard23AllowedMatchesConditionC2ERKS0_:
   40|  39.4k|  {
   41|  39.4k|    _device_match_rule = rhs._device_match_rule;
   42|  39.4k|    _interface_ptr = rhs._interface_ptr;
   43|  39.4k|  }
_ZNK8usbguard23AllowedMatchesCondition5cloneEv:
   63|  39.4k|  {
   64|  39.4k|    return new AllowedMatchesCondition(*this);
   65|  39.4k|  }

_ZN8usbguard19FixedStateConditionC2Ebb:
   32|   251k|  {
   33|   251k|  }
_ZN8usbguard19FixedStateConditionC2ERKS0_:
   38|   636k|  {
   39|   636k|  }
_ZNK8usbguard19FixedStateCondition5cloneEv:
   48|   636k|  {
   49|   636k|    return new FixedStateCondition(*this);
   50|   636k|  }

_ZN8usbguard18LocaltimeConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   37|  1.64k|  {
   38|  1.64k|    std::string time_begin;
   39|  1.64k|    std::string time_end;
   40|  1.64k|    const size_t dash_pos = time_range.find('-');
   41|       |
   42|  1.64k|    if (dash_pos == std::string::npos) {
  ------------------
  |  Branch (42:9): [True: 695, False: 945]
  ------------------
   43|    695|      time_begin = time_range;
   44|    695|    }
   45|    945|    else {
   46|    945|      time_begin = time_range.substr(0, dash_pos);
   47|    945|      time_end = time_range.substr(dash_pos + 1);
   48|    945|    }
   49|       |
   50|  1.64k|    _daytime_begin = stringToDaytime(time_begin);
   51|       |
   52|  1.64k|    if (!time_end.empty()) {
  ------------------
  |  Branch (52:9): [True: 922, False: 718]
  ------------------
   53|    922|      _daytime_end = stringToDaytime(time_end);
   54|    922|    }
   55|    718|    else {
   56|    718|      _daytime_end = _daytime_begin;
   57|    718|    }
   58|       |
   59|  1.64k|    if (_daytime_begin > _daytime_end) {
  ------------------
  |  Branch (59:9): [True: 23, False: 1.61k]
  ------------------
   60|     23|      throw Exception("LocaltimeCondition", "Invalid time range (begin > end)", time_range);
   61|     23|    }
   62|  1.64k|  }
_ZN8usbguard18LocaltimeConditionC2ERKS0_:
   66|  2.19k|  {
   67|  2.19k|    _daytime_begin = rhs._daytime_begin;
   68|  2.19k|    _daytime_end = rhs._daytime_end;
   69|  2.19k|  }
_ZNK8usbguard18LocaltimeCondition5cloneEv:
   84|  2.19k|  {
   85|  2.19k|    return new LocaltimeCondition(*this);
   86|  2.19k|  }
_ZN8usbguard18LocaltimeCondition15stringToDaytimeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  114|  2.56k|  {
  115|  2.56k|    USBGUARD_LOG(Trace) << "string=" << string;
  ------------------
  |  |  310|  2.56k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level)) \
  |  |  ------------------
  |  |  |  |  305|  2.56k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (310:7): [True: 0, False: 2.56k]
  |  |  ------------------
  |  |  311|  2.56k|    USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  305|      0|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |                   USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  300|      0|  #define USBGUARD_SOURCE_FILE __BASE_FILE__
  |  |  ------------------
  |  |                   USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  307|      0|#define USBGUARD_FUNCTION __func__
  |  |  ------------------
  ------------------
  116|  2.56k|    struct ::tm tm = { };
  117|       |
  118|  2.56k|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (118:9): [True: 2.23k, False: 328]
  ------------------
  119|  2.23k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (119:11): [True: 45, False: 2.18k]
  ------------------
  120|     45|        throw Exception("LocaltimeCondition", "Invalid time or range format", string);
  121|     45|      }
  122|  2.23k|    }
  123|       |
  124|  2.51k|    USBGUARD_LOG(Trace) << "tm=" << tmToString(&tm);
  ------------------
  |  |  310|  2.51k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level)) \
  |  |  ------------------
  |  |  |  |  305|  2.51k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (310:7): [True: 0, False: 2.51k]
  |  |  ------------------
  |  |  311|  2.51k|    USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  305|      0|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |                   USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  300|      0|  #define USBGUARD_SOURCE_FILE __BASE_FILE__
  |  |  ------------------
  |  |                   USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  307|      0|#define USBGUARD_FUNCTION __func__
  |  |  ------------------
  ------------------
  125|  2.51k|    return tm.tm_sec + 60*tm.tm_min + 60*60*tm.tm_hour;
  126|  2.56k|  }

_ZN8usbguard20RandomStateConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   36|  2.88k|  {
   37|  2.88k|  }
_ZN8usbguard20RandomStateConditionC2ERKS0_:
   44|  4.83k|  {
   45|  4.83k|  }
_ZNK8usbguard20RandomStateCondition5cloneEv:
   54|  4.83k|  {
   55|  4.83k|    return new RandomStateCondition(*this);
   56|  4.83k|  }

_ZN8usbguard20RuleAppliedConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   38|  1.19k|  {
   39|  1.19k|    _elapsed_time = std::chrono::steady_clock::duration(stringToSeconds(elapsed_time));
   40|  1.19k|  }
_ZN8usbguard20RuleAppliedConditionC2ERKS0_:
   45|  2.35k|  {
   46|  2.35k|  }
_ZNK8usbguard20RuleAppliedCondition5cloneEv:
   68|  2.35k|  {
   69|  2.35k|    return new RuleAppliedCondition(*this);
   70|  2.35k|  }
_ZN8usbguard20RuleAppliedCondition15stringToSecondsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   73|  1.19k|  {
   74|  1.19k|    struct ::tm tm = { };
   75|       |
   76|  1.19k|    if (string.empty() || string == "") {
  ------------------
  |  Branch (76:9): [True: 364, False: 835]
  |  Branch (76:27): [True: 0, False: 835]
  ------------------
   77|    364|      return 0;
   78|    364|    }
   79|       |
   80|    835|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (80:9): [True: 639, False: 196]
  ------------------
   81|    639|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (81:11): [True: 441, False: 198]
  ------------------
   82|    441|        if (::strptime(string.c_str(), "%s", &tm) == nullptr) {
  ------------------
  |  Branch (82:13): [True: 12, False: 429]
  ------------------
   83|     12|          throw std::runtime_error("Invalid time string. Expecing either HH:MM or HH:MM:SS format.");
   84|     12|        }
   85|    441|      }
   86|    639|    }
   87|       |
   88|    823|    return tm.tm_sec + 60*tm.tm_min + 60*60*tm.tm_hour;
   89|    835|  }

_ZN8usbguard22RuleEvaluatedConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   39|  1.99k|  {
   40|  1.99k|    _elapsed_time = std::chrono::steady_clock::duration(stringToSeconds(elapsed_time));
   41|  1.99k|  }
_ZN8usbguard22RuleEvaluatedConditionC2ERKS0_:
   46|  3.48k|  {
   47|  3.48k|  }
_ZNK8usbguard22RuleEvaluatedCondition5cloneEv:
   69|  3.48k|  {
   70|  3.48k|    return new RuleEvaluatedCondition(*this);
   71|  3.48k|  }
_ZN8usbguard22RuleEvaluatedCondition15stringToSecondsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   74|  1.99k|  {
   75|  1.99k|    struct ::tm tm = { };
   76|       |
   77|  1.99k|    if (string.empty() || string == "") {
  ------------------
  |  Branch (77:9): [True: 650, False: 1.34k]
  |  Branch (77:27): [True: 0, False: 1.34k]
  ------------------
   78|    650|      return 0;
   79|    650|    }
   80|       |
   81|  1.34k|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (81:9): [True: 1.10k, False: 237]
  ------------------
   82|  1.10k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (82:11): [True: 790, False: 315]
  ------------------
   83|    790|        if (::strptime(string.c_str(), "%s", &tm) == nullptr) {
  ------------------
  |  Branch (83:13): [True: 10, False: 780]
  ------------------
   84|     10|          throw std::runtime_error("Invalid time string. Expecing either HH:MM, HH:MM:SS or SS format.");
   85|     10|        }
   86|    790|      }
   87|  1.10k|    }
   88|       |
   89|  1.33k|    return tm.tm_sec + 60*tm.tm_min + 60*60*tm.tm_hour;
   90|  1.34k|  }

_ZN8usbguard10RuleParser19rule_parser_actionsINS0_7commentEE6apply0ERNS_4RuleE:
   57|  14.0k|      {
   58|  14.0k|        if (rule.getTarget() == Rule::Target::Invalid) {
  ------------------
  |  Branch (58:13): [True: 29, False: 13.9k]
  ------------------
   59|     29|          rule.setTarget(Rule::Target::Empty);
   60|     29|        }
   61|  14.0k|      }
_ZN8usbguard10RuleParser19rule_parser_actionsINS0_6targetEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
   68|  43.4k|      {
   69|  43.4k|        try {
   70|  43.4k|          rule.setTarget(Rule::targetFromString(in.string()));
   71|  43.4k|        }
   72|  43.4k|        catch (const std::exception& ex) {
   73|      0|          throw tao::pegtl::parse_error(ex.what(), in);
   74|      0|        }
   75|  43.4k|      }
_ZN8usbguard10RuleParser19rule_parser_actionsINS0_9device_idEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
   82|  2.80k|      {
   83|  2.80k|        try {
   84|  2.80k|          std::vector<std::string> tokens;
   85|  2.80k|          tokenizeString(in.string(), tokens, ":");
   86|  2.80k|          const USBDeviceID device_id(tokens[0], tokens[1]);
   87|  2.80k|          rule.setDeviceID(device_id);
   88|  2.80k|        }
   89|  2.80k|        catch (const std::exception& ex) {
   90|      8|          throw tao::pegtl::parse_error(ex.what(), in);
   91|      8|        }
   92|  2.80k|      }
_ZN8usbguard10RuleParser10id_actionsINS0_6str_idEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  150|  2.83k|      {
  151|  2.83k|        if (!rule.attributeDeviceID().empty()) {
  ------------------
  |  Branch (151:13): [True: 2, False: 2.83k]
  ------------------
  152|      2|          throw tao::pegtl::parse_error("id attribute already defined", in);
  153|      2|        }
  154|  2.83k|      }
_ZN8usbguard10RuleParser10id_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  178|  1.22k|      {
  179|  1.22k|        try {
  180|  1.22k|          rule.attributeDeviceID().setSetOperator(Rule::setOperatorFromString(in.string()));
  181|  1.22k|        }
  182|  1.22k|        catch (const std::exception& ex) {
  183|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  184|      0|        }
  185|  1.22k|      }
_ZN8usbguard10RuleParser10id_actionsINS0_15device_id_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  161|   724k|      {
  162|   724k|        try {
  163|   724k|          std::vector<std::string> tokens;
  164|   724k|          tokenizeString(in.string(), tokens, ":");
  165|   724k|          const USBDeviceID device_id(tokens[0], tokens[1]);
  166|   724k|          rule.attributeDeviceID().append(device_id);
  167|   724k|        }
  168|   724k|        catch (const std::exception& ex) {
  169|      4|          throw tao::pegtl::parse_error(ex.what(), in);
  170|      4|        }
  171|   724k|      }
_ZN8usbguard10RuleParser12name_actionsINS0_8str_nameEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  108|  4.91k|      {
  109|  4.91k|        if (!rule.attributeName().empty()) {
  ------------------
  |  Branch (109:13): [True: 2, False: 4.91k]
  ------------------
  110|      2|          throw tao::pegtl::parse_error("name attribute already defined", in);
  111|      2|        }
  112|  4.91k|      }
_ZN8usbguard10RuleParser12name_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  133|  2.37k|      {
  134|  2.37k|        try {
  135|  2.37k|          rule.attributeName().setSetOperator(Rule::setOperatorFromString(in.string()));
  136|  2.37k|        }
  137|  2.37k|        catch (const std::exception& ex) {
  138|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  139|      0|        }
  140|  2.37k|      }
_ZN8usbguard10RuleParser12name_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  119|   482k|      {
  120|   482k|        try {
  121|   482k|          rule.attributeName().append(stringValueFromRule(in.string()));
  122|   482k|        }
  123|   482k|        catch (const std::exception& ex) {
  124|     67|          throw tao::pegtl::parse_error(ex.what(), in);
  125|     67|        }
  126|   482k|      }
RuleParser.cpp:_ZN8usbguard10RuleParserL19stringValueFromRuleERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   96|   517k|    {
   97|   517k|      const std::string string_raw(value.substr(1, value.size() - 2));
   98|   517k|      return Utility::unescapeString(string_raw);
   99|   517k|    }
_ZN8usbguard10RuleParser12hash_actionsINS0_8str_hashEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  195|  4.55k|      {
  196|  4.55k|        if (!rule.attributeHash().empty()) {
  ------------------
  |  Branch (196:13): [True: 2, False: 4.55k]
  ------------------
  197|      2|          throw tao::pegtl::parse_error("hash attribute already defined", in);
  198|      2|        }
  199|  4.55k|      }
_ZN8usbguard10RuleParser12hash_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  220|  2.07k|      {
  221|  2.07k|        try {
  222|  2.07k|          rule.attributeHash().setSetOperator(Rule::setOperatorFromString(in.string()));
  223|  2.07k|        }
  224|  2.07k|        catch (const std::exception& ex) {
  225|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  226|      0|        }
  227|  2.07k|      }
_ZN8usbguard10RuleParser12hash_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  206|  9.68k|      {
  207|  9.68k|        try {
  208|  9.68k|          rule.attributeHash().append(stringValueFromRule(in.string()));
  209|  9.68k|        }
  210|  9.68k|        catch (const std::exception& ex) {
  211|     71|          throw tao::pegtl::parse_error(ex.what(), in);
  212|     71|        }
  213|  9.68k|      }
_ZN8usbguard10RuleParser19parent_hash_actionsINS0_15str_parent_hashEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  237|  3.05k|      {
  238|  3.05k|        if (!rule.attributeParentHash().empty()) {
  ------------------
  |  Branch (238:13): [True: 2, False: 3.05k]
  ------------------
  239|      2|          throw tao::pegtl::parse_error("parent-hash attribute already defined", in);
  240|      2|        }
  241|  3.05k|      }
_ZN8usbguard10RuleParser19parent_hash_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  262|  1.44k|      {
  263|  1.44k|        try {
  264|  1.44k|          rule.attributeParentHash().setSetOperator(Rule::setOperatorFromString(in.string()));
  265|  1.44k|        }
  266|  1.44k|        catch (const std::exception& ex) {
  267|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  268|      0|        }
  269|  1.44k|      }
_ZN8usbguard10RuleParser19parent_hash_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  248|  5.40k|      {
  249|  5.40k|        try {
  250|  5.40k|          rule.attributeParentHash().append(stringValueFromRule(in.string()));
  251|  5.40k|        }
  252|  5.40k|        catch (const std::exception& ex) {
  253|     49|          throw tao::pegtl::parse_error(ex.what(), in);
  254|     49|        }
  255|  5.40k|      }
_ZN8usbguard10RuleParser14serial_actionsINS0_10str_serialEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  279|  3.03k|      {
  280|  3.03k|        if (!rule.attributeSerial().empty()) {
  ------------------
  |  Branch (280:13): [True: 3, False: 3.03k]
  ------------------
  281|      3|          throw tao::pegtl::parse_error("serial attribute already defined", in);
  282|      3|        }
  283|  3.03k|      }
_ZN8usbguard10RuleParser14serial_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  304|  1.00k|      {
  305|  1.00k|        try {
  306|  1.00k|          rule.attributeSerial().setSetOperator(Rule::setOperatorFromString(in.string()));
  307|  1.00k|        }
  308|  1.00k|        catch (const std::exception& ex) {
  309|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  310|      0|        }
  311|  1.00k|      }
_ZN8usbguard10RuleParser14serial_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  290|  4.36k|      {
  291|  4.36k|        try {
  292|  4.36k|          rule.attributeSerial().append(stringValueFromRule(in.string()));
  293|  4.36k|        }
  294|  4.36k|        catch (const std::exception& ex) {
  295|     65|          throw tao::pegtl::parse_error(ex.what(), in);
  296|     65|        }
  297|  4.36k|      }
_ZN8usbguard10RuleParser16via_port_actionsINS0_12str_via_portEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  407|  3.16k|      {
  408|  3.16k|        if (!rule.attributeViaPort().empty()) {
  ------------------
  |  Branch (408:13): [True: 2, False: 3.16k]
  ------------------
  409|      2|          throw tao::pegtl::parse_error("via-port attribute already defined", in);
  410|      2|        }
  411|  3.16k|      }
_ZN8usbguard10RuleParser16via_port_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  432|  1.36k|      {
  433|  1.36k|        try {
  434|  1.36k|          rule.attributeViaPort().setSetOperator(Rule::setOperatorFromString(in.string()));
  435|  1.36k|        }
  436|  1.36k|        catch (const std::exception& ex) {
  437|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  438|      0|        }
  439|  1.36k|      }
_ZN8usbguard10RuleParser16via_port_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  418|  4.45k|      {
  419|  4.45k|        try {
  420|  4.45k|          rule.attributeViaPort().append(stringValueFromRule(in.string()));
  421|  4.45k|        }
  422|  4.45k|        catch (const std::exception& ex) {
  423|     66|          throw tao::pegtl::parse_error(ex.what(), in);
  424|     66|        }
  425|  4.45k|      }
_ZN8usbguard10RuleParser22with_interface_actionsINS0_18str_with_interfaceEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  449|  3.60k|      {
  450|  3.60k|        if (!rule.attributeWithInterface().empty()) {
  ------------------
  |  Branch (450:13): [True: 2, False: 3.60k]
  ------------------
  451|      2|          throw tao::pegtl::parse_error("with-interface attribute already defined", in);
  452|      2|        }
  453|  3.60k|      }
_ZN8usbguard10RuleParser22with_interface_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  475|  1.86k|      {
  476|  1.86k|        try {
  477|  1.86k|          rule.attributeWithInterface().setSetOperator(Rule::setOperatorFromString(in.string()));
  478|  1.86k|        }
  479|  1.86k|        catch (const std::exception& ex) {
  480|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  481|      0|        }
  482|  1.86k|      }
_ZN8usbguard10RuleParser22with_interface_actionsINS0_15interface_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  460|   110k|      {
  461|   110k|        try {
  462|   110k|          const USBInterfaceType interface_type(in.string());
  463|   110k|          rule.attributeWithInterface().append(interface_type);
  464|   110k|        }
  465|   110k|        catch (const std::exception& ex) {
  466|      3|          throw tao::pegtl::parse_error(ex.what(), in);
  467|      3|        }
  468|   110k|      }
_ZN8usbguard10RuleParser25with_connect_type_actionsINS0_21str_with_connect_typeEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  363|  3.52k|      {
  364|  3.52k|        if (!rule.attributeWithConnectType().empty()) {
  ------------------
  |  Branch (364:13): [True: 2, False: 3.51k]
  ------------------
  365|      2|          throw tao::pegtl::parse_error(
  366|      2|            "with-connect-type attribute already defined", in);
  367|      2|        }
  368|  3.52k|      }
_ZN8usbguard10RuleParser25with_connect_type_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  389|  1.44k|      {
  390|  1.44k|        try {
  391|  1.44k|          rule.attributeWithConnectType().setSetOperator(
  392|  1.44k|            Rule::setOperatorFromString(in.string()));
  393|  1.44k|        }
  394|  1.44k|        catch (const std::exception& ex) {
  395|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  396|      0|        }
  397|  1.44k|      }
_ZN8usbguard10RuleParser25with_connect_type_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  375|  4.85k|      {
  376|  4.85k|        try {
  377|  4.85k|          rule.attributeWithConnectType().append(stringValueFromRule(in.string()));
  378|  4.85k|        }
  379|  4.85k|        catch (const std::exception& ex) {
  380|     52|          throw tao::pegtl::parse_error(ex.what(), in);
  381|     52|        }
  382|  4.85k|      }
_ZN8usbguard10RuleParser17condition_actionsINS0_6str_ifEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  492|  6.79k|      {
  493|  6.79k|        if (!rule.attributeConditions().empty()) {
  ------------------
  |  Branch (493:13): [True: 5, False: 6.78k]
  ------------------
  494|      5|          throw tao::pegtl::parse_error("conditions already defined", in);
  495|      5|        }
  496|  6.79k|      }
_ZN8usbguard10RuleParser17condition_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  517|  1.86k|      {
  518|  1.86k|        try {
  519|  1.86k|          rule.attributeConditions().setSetOperator(Rule::setOperatorFromString(in.string()));
  520|  1.86k|        }
  521|  1.86k|        catch (const std::exception& ex) {
  522|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  523|      0|        }
  524|  1.86k|      }
_ZN8usbguard10RuleParser17condition_actionsINS0_9conditionEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  503|   289k|      {
  504|   289k|        try {
  505|   289k|          rule.attributeConditions().append(RuleCondition(in.string()));
  506|   289k|        }
  507|   289k|        catch (const std::exception& ex) {
  508|  1.58k|          throw tao::pegtl::parse_error(ex.what(), in);
  509|  1.58k|        }
  510|   289k|      }
_ZN8usbguard10RuleParser13label_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  346|  1.63k|      {
  347|  1.63k|        try {
  348|  1.63k|          rule.attributeLabel().setSetOperator(Rule::setOperatorFromString(in.string()));
  349|  1.63k|        }
  350|  1.63k|        catch (const std::exception& ex) {
  351|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  352|      0|        }
  353|  1.63k|      }
_ZN8usbguard10RuleParser13label_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  332|  6.21k|      {
  333|  6.21k|        try {
  334|  6.21k|          rule.attributeLabel().append(stringValueFromRule(in.string()));
  335|  6.21k|        }
  336|  6.21k|        catch (const std::exception& ex) {
  337|     65|          throw tao::pegtl::parse_error(ex.what(), in);
  338|     65|        }
  339|  6.21k|      }

_ZN8usbguard11RulePrivateC2Ev:
   43|   107k|  {
   44|   107k|    _rule_id = Rule::DefaultID;
   45|   107k|    _target = Rule::Target::Invalid;
   46|   107k|    _conditions_state = 0;
   47|   107k|  }
_ZN8usbguard11RulePrivateC2ERKS0_:
   60|  68.5k|  {
   61|  68.5k|    *this = rhs;
   62|  68.5k|  }
_ZN8usbguard11RulePrivate9setTargetENS_4Rule6TargetE:
  227|  43.4k|  {
  228|  43.4k|    _target = target;
  229|  43.4k|  }
_ZNK8usbguard11RulePrivate9getTargetEv:
  232|  14.0k|  {
  233|  14.0k|    return _target;
  234|  14.0k|  }
_ZN8usbguard11RulePrivate11setDeviceIDERKNS_11USBDeviceIDE:
  237|  2.80k|  {
  238|  2.80k|    _device_id.set(device_id);
  239|  2.80k|  }
_ZN8usbguard11RulePrivate17attributeDeviceIDEv:
  252|   728k|  {
  253|   728k|    return _device_id;
  254|   728k|  }
_ZN8usbguard11RulePrivate15attributeSerialEv:
  272|  8.40k|  {
  273|  8.40k|    return _serial;
  274|  8.40k|  }
_ZN8usbguard11RulePrivate14attributeLabelEv:
  292|  7.84k|  {
  293|  7.84k|    return _label;
  294|  7.84k|  }
_ZN8usbguard11RulePrivate24attributeWithConnectTypeEv:
  312|  9.81k|  {
  313|  9.81k|    return _with_connect_type;
  314|  9.81k|  }
_ZN8usbguard11RulePrivate13attributeNameEv:
  332|   489k|  {
  333|   489k|    return _name;
  334|   489k|  }
_ZN8usbguard11RulePrivate13attributeHashEv:
  352|  16.3k|  {
  353|  16.3k|    return _hash;
  354|  16.3k|  }
_ZN8usbguard11RulePrivate19attributeParentHashEv:
  372|  9.91k|  {
  373|  9.91k|    return _parent_hash;
  374|  9.91k|  }
_ZN8usbguard11RulePrivate16attributeViaPortEv:
  392|  8.98k|  {
  393|  8.98k|    return _via_port;
  394|  8.98k|  }
_ZN8usbguard11RulePrivate22attributeWithInterfaceEv:
  402|   115k|  {
  403|   115k|    return _with_interface;
  404|   115k|  }
_ZN8usbguard11RulePrivate19attributeConditionsEv:
  412|   298k|  {
  413|   298k|    return _conditions;
  414|   298k|  }

_ZN8usbguard11RulePrivateD2Ev:
   55|   176k|    ~RulePrivate() = default;
_ZN8usbguard11RulePrivate8MetaDataC2Ev:
   39|   176k|      {
   40|   176k|      }
_ZN8usbguard11RulePrivateaSERKS0_:
   54|  68.5k|    RulePrivate& operator=(const RulePrivate& rhs) = default;

_ZN8usbguard7Utility14unescapeStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   75|   517k|    {
   76|   517k|      std::string result;
   77|   517k|      bool escaped = false;
   78|   517k|      const std::locale c_locale("C");
   79|       |
   80|  1.02M|      for (auto it = string_escaped.cbegin(); it < string_escaped.cend(); ++it) {
  ------------------
  |  Branch (80:47): [True: 507k, False: 517k]
  ------------------
   81|   507k|        const char c = *it;
   82|       |
   83|       |        /*
   84|       |         * Handle an escape sequence if needed, otherwise just
   85|       |         * append the current character.
   86|       |         */
   87|   507k|        if (escaped) {
  ------------------
  |  Branch (87:13): [True: 2.89k, False: 504k]
  ------------------
   88|  2.89k|          switch (c) {
   89|    316|          case '"':
  ------------------
  |  Branch (89:11): [True: 316, False: 2.57k]
  ------------------
   90|    316|            result.append("\"");
   91|    316|            break;
   92|       |
   93|    427|          case '\\':
  ------------------
  |  Branch (93:11): [True: 427, False: 2.46k]
  ------------------
   94|    427|            result.append("\\");
   95|    427|            break;
   96|       |
   97|  1.71k|          case 'x': {
  ------------------
  |  Branch (97:11): [True: 1.71k, False: 1.17k]
  ------------------
   98|       |            /* hexadecimal representation of a byte \xHH */
   99|  1.71k|            if (std::distance(string_escaped.end(), it) >=2) {
  ------------------
  |  Branch (99:17): [True: 0, False: 1.71k]
  ------------------
  100|      0|              throw std::runtime_error("Invalid escape sequence");
  101|      0|            }
  102|       |
  103|  1.71k|            const char hb[] = { *(it + 1), *(it + 2) };
  104|       |
  105|  1.71k|            if (!std::isxdigit(hb[0], c_locale) || !std::isxdigit(hb[1], c_locale)) {
  ------------------
  |  Branch (105:17): [True: 0, False: 1.71k]
  |  Branch (105:52): [True: 0, False: 1.71k]
  ------------------
  106|      0|              throw std::runtime_error("Invalid \\xHH escape sequence: HH is not a hexadecimal number");
  107|      0|            }
  108|       |
  109|  1.71k|            const std::string hexbyte(hb, 2);
  110|  1.71k|            result.push_back((char)stringToNumber<uint8_t>(hexbyte, 16));
  111|  1.71k|            ++it;
  112|  1.71k|            ++it;
  113|  1.71k|          }
  114|      0|          break;
  115|       |
  116|    435|          default:
  ------------------
  |  Branch (116:11): [True: 435, False: 2.45k]
  ------------------
  117|    435|            throw std::runtime_error("Unknown escape sequence");
  118|  2.89k|          }
  119|       |
  120|  2.45k|          escaped = false;
  121|  2.45k|        }
  122|   504k|        else {
  123|   504k|          if (c == '\\') {
  ------------------
  |  Branch (123:15): [True: 2.89k, False: 501k]
  ------------------
  124|  2.89k|            escaped = true;
  125|  2.89k|          }
  126|   501k|          else {
  127|   501k|            result.push_back(c);
  128|   501k|          }
  129|   504k|        }
  130|   507k|      }
  131|       |
  132|   517k|      if (escaped) {
  ------------------
  |  Branch (132:11): [True: 0, False: 517k]
  ------------------
  133|      0|        throw std::runtime_error("Invalid escape sequence");
  134|      0|      }
  135|       |
  136|   517k|      return result;
  137|   517k|    }

_ZN8usbguard9ExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_:
   48|     68|    {
   49|     68|    }
_ZNK8usbguard9Exception4whatEv:
  105|     68|    {
  106|     68|      return "usbguard::Exception";
  107|     68|    }

_ZN8usbguard7LogSinkC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  101|      2|  {
  102|      2|  }
_ZNK8usbguard7LogSink4nameEv:
  109|      2|  {
  110|      2|    return _name;
  111|      2|  }
_ZN8usbguard6LoggerC2Ev:
  280|      2|  {
  281|      2|    const char* const envval = getenv("USBGUARD_DEBUG");
  282|       |
  283|       |    /*
  284|       |     * If USBGUARD_DEBUG=1 is set in the current environment,
  285|       |     * set the debugging level to the highest level.
  286|       |     */
  287|      2|    if (envval != nullptr && strcmp(envval, "1") == 0) {
  ------------------
  |  Branch (287:9): [True: 0, False: 2]
  |  Branch (287:30): [True: 0, False: 0]
  ------------------
  288|      0|      _level = LogStream::Level::Trace;
  289|      0|    }
  290|       |
  291|      2|    setOutputConsole(true);
  292|      2|  }
_ZNK8usbguard6Logger4lockEv:
  299|  5.08k|  {
  300|  5.08k|    return std::unique_lock<std::mutex>(_mutex);
  301|  5.08k|  }
_ZNK8usbguard6Logger9isEnabledENS_9LogStream5LevelE:
  311|  5.07k|  {
  312|  5.07k|    auto L = lock();
  313|  5.07k|    return (_enabled && _level >= level);
  ------------------
  |  Branch (313:13): [True: 5.07k, False: 0]
  |  Branch (313:25): [True: 0, False: 5.07k]
  ------------------
  314|  5.07k|  }
_ZN8usbguard6Logger16setOutputConsoleEb:
  317|      2|  {
  318|      2|    auto L = lock();
  319|       |
  320|      2|    if (state == true) {
  ------------------
  |  Branch (320:9): [True: 2, False: 0]
  ------------------
  321|      2|      std::unique_ptr<LogSink> sink(new ConsoleSink);
  322|      2|      addOutputSink_nolock(sink);
  323|      2|    }
  324|      0|    else {
  325|      0|      delOutputSink_nolock("console");
  326|      0|    }
  327|      2|  }
_ZN8usbguard6Logger20addOutputSink_nolockERNSt3__110unique_ptrINS_7LogSinkENS1_14default_deleteIS3_EEEE:
  375|      2|  {
  376|      2|    _sinks.emplace(sink->name(), std::move(sink));
  377|      2|  }
_ZN8usbguard11ConsoleSinkC2Ev:
  151|      2|    {
  152|      2|    }
_ZN8usbguard11OStreamSinkC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS1_13basic_ostreamIcS4_EE:
  122|      2|    {
  123|      2|    }

_ZN8usbguard4RuleC2Ev:
   43|   107k|  {
   44|   107k|  }
_ZN8usbguard4RuleD2Ev:
   46|   107k|  Rule::~Rule() = default;
_ZN8usbguard4RuleaSERKS0_:
   54|  68.5k|  {
   55|  68.5k|    d_pointer.reset(new RulePrivate(*rhs.d_pointer));
   56|  68.5k|    return *this;
   57|  68.5k|  }
_ZN8usbguard4Rule9setTargetENS0_6TargetE:
   70|  43.4k|  {
   71|  43.4k|    d_pointer->setTarget(target);
   72|  43.4k|  }
_ZNK8usbguard4Rule9getTargetEv:
   75|  14.0k|  {
   76|  14.0k|    return d_pointer->getTarget();
   77|  14.0k|  }
_ZN8usbguard4Rule11setDeviceIDERKNS_11USBDeviceIDE:
   80|  2.80k|  {
   81|  2.80k|    d_pointer->setDeviceID(value);
   82|  2.80k|  }
_ZN8usbguard4Rule17attributeDeviceIDEv:
   95|   728k|  {
   96|   728k|    return d_pointer->attributeDeviceID();
   97|   728k|  }
_ZN8usbguard4Rule15attributeSerialEv:
  115|  8.40k|  {
  116|  8.40k|    return d_pointer->attributeSerial();
  117|  8.40k|  }
_ZN8usbguard4Rule14attributeLabelEv:
  135|  7.84k|  {
  136|  7.84k|    return d_pointer->attributeLabel();
  137|  7.84k|  }
_ZN8usbguard4Rule24attributeWithConnectTypeEv:
  155|  9.81k|  {
  156|  9.81k|    return d_pointer->attributeWithConnectType();
  157|  9.81k|  }
_ZN8usbguard4Rule13attributeNameEv:
  175|   489k|  {
  176|   489k|    return d_pointer->attributeName();
  177|   489k|  }
_ZN8usbguard4Rule13attributeHashEv:
  195|  16.3k|  {
  196|  16.3k|    return d_pointer->attributeHash();
  197|  16.3k|  }
_ZN8usbguard4Rule19attributeParentHashEv:
  215|  9.91k|  {
  216|  9.91k|    return d_pointer->attributeParentHash();
  217|  9.91k|  }
_ZN8usbguard4Rule16attributeViaPortEv:
  235|  8.98k|  {
  236|  8.98k|    return d_pointer->attributeViaPort();
  237|  8.98k|  }
_ZN8usbguard4Rule22attributeWithInterfaceEv:
  245|   115k|  {
  246|   115k|    return d_pointer->attributeWithInterface();
  247|   115k|  }
_ZN8usbguard4Rule19attributeConditionsEv:
  255|   298k|  {
  256|   298k|    return d_pointer->attributeConditions();
  257|   298k|  }
_ZN8usbguard4Rule16targetFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  333|  43.4k|  {
  334|  57.9k|    for (auto ttable_entry : target_ttable) {
  ------------------
  |  Branch (334:28): [True: 57.9k, False: 0]
  ------------------
  335|  57.9k|      if (ttable_entry.first == target_string) {
  ------------------
  |  Branch (335:11): [True: 43.4k, False: 14.5k]
  ------------------
  336|  43.4k|        return ttable_entry.second;
  337|  43.4k|      }
  338|  57.9k|    }
  339|       |
  340|      0|    throw std::runtime_error("Invalid rule target string");
  341|  43.4k|  }
_ZN8usbguard4Rule21setOperatorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  387|  16.2k|  {
  388|  57.2k|    for (auto ttable_entry : set_operator_ttable) {
  ------------------
  |  Branch (388:28): [True: 57.2k, False: 0]
  ------------------
  389|  57.2k|      if (ttable_entry.first == set_operator_string) {
  ------------------
  |  Branch (389:11): [True: 16.2k, False: 40.9k]
  ------------------
  390|  16.2k|        return ttable_entry.second;
  391|  16.2k|      }
  392|  57.2k|    }
  393|       |
  394|      0|    throw std::runtime_error("Invalid set operator string");
  395|  16.2k|  }

_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5emptyEv:
  300|  2.83k|      {
  301|  2.83k|        return count() == 0;
  302|  2.83k|      }
_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5countEv:
  289|  8.43k|      {
  290|  8.43k|        return _values.size();
  291|  8.43k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.22k|      {
  250|  1.22k|        _set_operator = op;
  251|  1.22k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE6appendERKS2_:
  279|   726k|      {
  280|   726k|        _values.push_back(value);
  281|   726k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
  300|  22.2k|      {
  301|  22.2k|        return count() == 0;
  302|  22.2k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5countEv:
  289|  22.2k|      {
  290|  22.2k|        return _values.size();
  291|  22.2k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14setSetOperatorENS0_11SetOperatorE:
  249|  11.3k|      {
  250|  11.3k|        _set_operator = op;
  251|  11.3k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6appendERKS8_:
  279|   517k|      {
  280|   517k|        _values.push_back(value);
  281|   517k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5emptyEv:
  300|  3.60k|      {
  301|  3.60k|        return count() == 0;
  302|  3.60k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5countEv:
  289|  3.60k|      {
  290|  3.60k|        return _values.size();
  291|  3.60k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.86k|      {
  250|  1.86k|        _set_operator = op;
  251|  1.86k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE6appendERKS2_:
  279|   110k|      {
  280|   110k|        _values.push_back(value);
  281|   110k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5emptyEv:
  300|  6.79k|      {
  301|  6.79k|        return count() == 0;
  302|  6.79k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5countEv:
  289|  6.79k|      {
  290|  6.79k|        return _values.size();
  291|  6.79k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.86k|      {
  250|  1.86k|        _set_operator = op;
  251|  1.86k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE6appendEOS2_:
  269|   288k|      {
  270|   288k|        _values.emplace_back(std::move(value));
  271|   288k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEaSERKS3_:
  241|  68.5k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEaSERKS9_:
  241|   479k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEaSERKS3_:
  241|  68.5k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEaSERKS3_:
  241|  68.5k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEC2EPKc:
  224|   176k|      {
  225|   176k|        _name = name;
  226|   176k|        _set_operator = SetOperator::Equals;
  227|   176k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPKc:
  224|  1.23M|      {
  225|  1.23M|        _name = name;
  226|  1.23M|        _set_operator = SetOperator::Equals;
  227|  1.23M|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEC2EPKc:
  224|   176k|      {
  225|   176k|        _name = name;
  226|   176k|        _set_operator = SetOperator::Equals;
  227|   176k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEC2EPKc:
  224|   176k|      {
  225|   176k|        _name = name;
  226|   176k|        _set_operator = SetOperator::Equals;
  227|   176k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE3setERKS2_:
  384|  2.80k|      {
  385|  2.80k|        if (count() > 1) {
  ------------------
  |  Branch (385:13): [True: 5, False: 2.79k]
  ------------------
  386|      5|          throw std::runtime_error("BUG: Setting single value for a multivalued attribute");
  387|      5|        }
  388|       |
  389|  2.79k|        if (count() == 0) {
  ------------------
  |  Branch (389:13): [True: 1.99k, False: 798]
  ------------------
  390|  1.99k|          append(value);
  391|  1.99k|        }
  392|    798|        else {
  393|    798|          _values[0] = value;
  394|    798|        }
  395|  2.79k|      }

_ZN8usbguard17RuleConditionBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
   37|  37.6k|  {
   38|  37.6k|  }
_ZN8usbguard17RuleConditionBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   43|   251k|  {
   44|   251k|  }
_ZN8usbguard17RuleConditionBaseC2ERKS0_:
   50|   688k|  {
   51|   688k|  }
_ZN8usbguard17RuleConditionBaseD2Ev:
   54|   978k|  {
   55|   978k|    fini();
   56|   978k|  }
_ZN8usbguard17RuleConditionBase4finiEv:
   64|   978k|  {
   65|   978k|  }
_ZN8usbguard17RuleConditionBase17getImplementationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  130|   289k|  {
  131|   289k|    if (condition_string.empty()) {
  ------------------
  |  Branch (131:9): [True: 0, False: 289k]
  ------------------
  132|      0|      throw std::runtime_error("Empty condition");
  133|      0|    }
  134|       |
  135|   289k|    const bool negated = condition_string[0] == '!';
  136|   289k|    const size_t identifier_start = negated ? 1 : 0;
  ------------------
  |  Branch (136:37): [True: 1.24k, False: 288k]
  ------------------
  137|   289k|    const size_t p_pos = condition_string.find_first_of('(');
  138|   289k|    std::string identifier;
  139|   289k|    std::string parameter;
  140|       |
  141|   289k|    if (p_pos == std::string::npos) {
  ------------------
  |  Branch (141:9): [True: 254k, False: 35.3k]
  ------------------
  142|       |      /*
  143|       |       * The rest of the condition_string should be
  144|       |       * a condition identifier -- without a parameter.
  145|       |       */
  146|   254k|      identifier = condition_string.substr(identifier_start);
  147|       |
  148|   254k|      if (identifier.size() < 1) {
  ------------------
  |  Branch (148:11): [True: 0, False: 254k]
  ------------------
  149|      0|        throw std::runtime_error("Invalid condition string. Missing identifier.");
  150|      0|      }
  151|   254k|    }
  152|  35.3k|    else {
  153|  35.3k|      const size_t parameter_size = condition_string.size() - p_pos;
  154|       |
  155|  35.3k|      if (parameter_size < 3 /* two parentheses + at least one character */) {
  ------------------
  |  Branch (155:11): [True: 5, False: 35.3k]
  ------------------
  156|      5|        throw std::runtime_error("Invalid condition string. Invalid parameter.");
  157|      5|      }
  158|       |
  159|  35.3k|      const size_t identifier_size = p_pos - identifier_start;
  160|  35.3k|      identifier = condition_string.substr(identifier_start, identifier_size);
  161|       |
  162|  35.3k|      if (condition_string[condition_string.size() - 1] != ')') {
  ------------------
  |  Branch (162:11): [True: 0, False: 35.3k]
  ------------------
  163|      0|        throw std::runtime_error("Invalid condition string. Malformed parameter.");
  164|      0|      }
  165|       |
  166|  35.3k|      parameter = condition_string.substr(p_pos + 1, parameter_size - 2);
  167|  35.3k|    }
  168|       |
  169|   289k|    return getImplementation(identifier, parameter, negated);
  170|   289k|  }
_ZN8usbguard17RuleConditionBase17getImplementationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
  174|   289k|  {
  175|   289k|    if (identifier == "allowed-matches") {
  ------------------
  |  Branch (175:9): [True: 29.9k, False: 259k]
  ------------------
  176|  29.9k|      return new AllowedMatchesCondition(parameter, negated);
  177|  29.9k|    }
  178|       |
  179|   259k|    if (identifier == "localtime") {
  ------------------
  |  Branch (179:9): [True: 1.64k, False: 258k]
  ------------------
  180|  1.64k|      return new LocaltimeCondition(parameter, negated);
  181|  1.64k|    }
  182|       |
  183|   258k|    if (identifier == "true") {
  ------------------
  |  Branch (183:9): [True: 250k, False: 7.61k]
  ------------------
  184|   250k|      return new FixedStateCondition(true, negated);
  185|   250k|    }
  186|       |
  187|  7.61k|    if (identifier == "false") {
  ------------------
  |  Branch (187:9): [True: 890, False: 6.72k]
  ------------------
  188|    890|      return new FixedStateCondition(false, negated);
  189|    890|    }
  190|       |
  191|  6.72k|    if (identifier == "random") {
  ------------------
  |  Branch (191:9): [True: 2.88k, False: 3.83k]
  ------------------
  192|  2.88k|      return new RandomStateCondition(parameter, negated);
  193|  2.88k|    }
  194|       |
  195|  3.83k|    if (identifier == "rule-applied") {
  ------------------
  |  Branch (195:9): [True: 1.19k, False: 2.63k]
  ------------------
  196|  1.19k|      return new RuleAppliedCondition(parameter, negated);
  197|  1.19k|    }
  198|       |
  199|  2.63k|    if (identifier == "rule-evaluated") {
  ------------------
  |  Branch (199:9): [True: 1.99k, False: 640]
  ------------------
  200|  1.99k|      return new RuleEvaluatedCondition(parameter, negated);
  201|  1.99k|    }
  202|       |
  203|    640|    throw std::runtime_error("Unknown rule condition");
  204|  2.63k|  }
_ZN8usbguard13RuleConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  212|   289k|  {
  213|   289k|  }
_ZN8usbguard13RuleConditionC2ERKS0_:
  217|   688k|  {
  218|   688k|  }
_ZN8usbguard13RuleConditionC2EOS0_:
  222|   288k|  {
  223|   288k|  }

_ZN8usbguard19parseRuleFromStringERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_mb:
   46|  38.3k|  {
   47|  38.3k|    try {
   48|  38.3k|      Rule rule;
   49|  38.3k|      tao::pegtl::string_input<> input(rule_spec, file);
   50|       |
   51|  38.3k|      if (!trace) {
  ------------------
  |  Branch (51:11): [True: 38.3k, False: 0]
  ------------------
   52|  38.3k|        tao::pegtl::parse<RuleParser::rule_grammar, RuleParser::rule_parser_actions>(input, rule);
   53|  38.3k|      }
   54|      0|      else {
   55|      0|#if TAO_PEGTL_VERSION_MAJOR >= 3
   56|      0|        tao::pegtl::complete_trace<RuleParser::rule_grammar, RuleParser::rule_parser_actions>(input, rule);
   57|       |#else
   58|       |        tao::pegtl::parse<RuleParser::rule_grammar, RuleParser::rule_parser_actions, tao::pegtl::tracer>(input, rule);
   59|       |#endif
   60|      0|      }
   61|       |
   62|  38.3k|      return rule;
   63|  38.3k|    }
   64|  38.3k|    catch (const tao::pegtl::parse_error& ex) {
   65|  8.77k|      RuleParserError error(rule_spec);
   66|  8.77k|      error.setHint(ex.what());
   67|  8.77k|#if TAO_PEGTL_VERSION_MAJOR >= 3
   68|  8.77k|      error.setOffset(ex.positions().front().column);
   69|       |#else
   70|       |      error.setOffset(ex.positions[0].byte_in_line);
   71|       |#endif
   72|       |
   73|  8.77k|      if (!file.empty() || line != 0) {
  ------------------
  |  Branch (73:11): [True: 7.95k, False: 824]
  |  Branch (73:28): [True: 0, False: 824]
  ------------------
   74|  7.95k|        error.setFileInfo(file, line);
   75|  7.95k|      }
   76|       |
   77|  8.77k|      throw error;
   78|  8.77k|    }
   79|  38.3k|    catch (const std::exception& ex) {
   80|      0|      throw;
   81|      0|    }
   82|  38.3k|  }

_ZN8usbguard15RuleParserErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_mj:
   54|  8.77k|    {
   55|  8.77k|    }
_ZN8usbguard15RuleParserError7setHintERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   63|  8.77k|    {
   64|  8.77k|      _hint = hint;
   65|  8.77k|    }
_ZN8usbguard15RuleParserError9setOffsetEm:
   73|  8.77k|    {
   74|  8.77k|      _offset = offset;
   75|  8.77k|    }
_ZN8usbguard15RuleParserError11setFileInfoERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmm:
   85|  7.95k|    {
   86|  7.95k|      _file = file;
   87|  7.95k|      _line = error_line;
   88|  7.95k|      _offset = error_offset;
   89|  7.95k|    }
_ZNK8usbguard15RuleParserError4whatEv:
   97|    824|    {
   98|    824|      return "RuleParserError";
   99|    824|    }

_ZN8usbguard11USBDeviceIDC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   35|   727k|  {
   36|   727k|    checkDeviceID(vendor_id, product_id);
   37|   727k|    setVendorID(vendor_id);
   38|   727k|    setProductID(product_id);
   39|   727k|  }
_ZN8usbguard11USBDeviceID13checkDeviceIDERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   42|  2.18M|  {
   43|  2.18M|    if (vendor_id.empty() || vendor_id == "*") {
  ------------------
  |  Branch (43:9): [True: 0, False: 2.18M]
  |  Branch (43:30): [True: 2.17M, False: 6.79k]
  ------------------
   44|       |      /* product id must be empty or "*" */
   45|  2.17M|      if (!product_id.empty() && product_id != "*") {
  ------------------
  |  Branch (45:11): [True: 1.44M, False: 724k]
  |  Branch (45:34): [True: 7, False: 1.44M]
  ------------------
   46|      7|        throw std::runtime_error("Invalid USB device id format");
   47|      7|      }
   48|  2.17M|    }
   49|       |
   50|  2.18M|    if (vendor_id.size() > USB_VID_STRING_MAX_LENGTH) {
  ------------------
  |  Branch (50:9): [True: 0, False: 2.18M]
  ------------------
   51|      0|      throw std::runtime_error("Vendor ID string size out of range");
   52|      0|    }
   53|       |
   54|  2.18M|    if (product_id.size() > USB_PID_STRING_MAX_LENGTH) {
  ------------------
  |  Branch (54:9): [True: 0, False: 2.18M]
  ------------------
   55|      0|      throw std::runtime_error("Product ID string size out of range");
   56|      0|    }
   57|  2.18M|  }
_ZN8usbguard11USBDeviceID11setVendorIDERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   60|   727k|  {
   61|   727k|    checkDeviceID(vendor_id, _product_id);
   62|   727k|    _vendor_id = vendor_id;
   63|   727k|  }
_ZN8usbguard11USBDeviceID12setProductIDERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   66|   727k|  {
   67|   727k|    checkDeviceID(_vendor_id, product_id);
   68|   727k|    _product_id = product_id;
   69|   727k|  }
_ZN8usbguard16USBInterfaceTypeC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  153|   110k|  {
  154|   110k|    std::vector<std::string> tokens;
  155|   110k|    tokenizeString(type_string, tokens, ":", /*trim_empty=*/false);
  156|   110k|    _bClass = 0;
  157|   110k|    _bSubClass = 0;
  158|   110k|    _bProtocol = 0;
  159|   110k|    _mask = 0;
  160|       |
  161|   110k|    if (tokens.size() != 3) {
  ------------------
  |  Branch (161:9): [True: 0, False: 110k]
  ------------------
  162|      0|      throw std::runtime_error("Invalid type_string");
  163|      0|    }
  164|       |
  165|   110k|    if (tokens[0].size() != 2) {
  ------------------
  |  Branch (165:9): [True: 0, False: 110k]
  ------------------
  166|      0|      throw std::runtime_error("Invalid type_string");
  167|      0|    }
  168|   110k|    else {
  169|   110k|      _bClass = stringToNumber<uint8_t>(tokens[0], 16);
  170|   110k|      _mask |= MatchClass;
  171|   110k|    }
  172|       |
  173|   110k|    if (tokens[1] != "*") {
  ------------------
  |  Branch (173:9): [True: 27.8k, False: 82.6k]
  ------------------
  174|  27.8k|      if (tokens[1].size() != 2) {
  ------------------
  |  Branch (174:11): [True: 0, False: 27.8k]
  ------------------
  175|      0|        throw std::runtime_error("Invalid type_string");
  176|      0|      }
  177|  27.8k|      else {
  178|  27.8k|        _bSubClass = stringToNumber<uint8_t>(tokens[1], 16);
  179|  27.8k|        _mask |= MatchSubClass;
  180|  27.8k|      }
  181|  27.8k|    }
  182|       |
  183|   110k|    if (tokens[2] != "*") {
  ------------------
  |  Branch (183:9): [True: 652, False: 109k]
  ------------------
  184|    652|      if (tokens[2].size() != 2) {
  ------------------
  |  Branch (184:11): [True: 0, False: 652]
  ------------------
  185|      0|        throw std::runtime_error("Invalid type_string");
  186|      0|      }
  187|    652|      else {
  188|    652|        _bProtocol = stringToNumber<uint8_t>(tokens[2], 16);
  189|    652|        _mask |= MatchProtocol;
  190|    652|      }
  191|    652|    }
  192|       |
  193|   110k|    if (!(_mask == (MatchAll) ||
  ------------------
  |  Branch (193:11): [True: 649, False: 109k]
  ------------------
  194|   110k|        _mask == (MatchClass|MatchSubClass) ||
  ------------------
  |  Branch (194:9): [True: 27.1k, False: 82.6k]
  ------------------
  195|   110k|        _mask == (MatchClass))) {
  ------------------
  |  Branch (195:9): [True: 82.6k, False: 3]
  ------------------
  196|      3|      throw std::runtime_error("Invalid type_string");
  197|      3|    }
  198|   110k|  }

_ZN8usbguard11USBDeviceIDC2ERKS0_:
  183|  3.80M|    USBDeviceID(const USBDeviceID& rhs) = default;
_ZN8usbguard11USBDeviceIDaSERKS0_:
  191|    798|    USBDeviceID& operator=(const USBDeviceID& rhs) = default;

LLVMFuzzerTestOneInput:
   38|  8.39k|{
   39|  8.39k|  std::string rule_spec(data, data + size);
   40|       |
   41|  8.39k|  try {
   42|  8.39k|    auto rule = parseRuleFromString(rule_spec, "fuzzer_input", 0,
   43|  8.39k|        false /*trace*/);
   44|  8.39k|  }
   45|  8.39k|  catch (const RuleParserError& ex) {
   46|       |    // An invalid rule is ok.
   47|  7.95k|  }
   48|       |
   49|  8.39k|  return 0;
   50|  8.39k|}

_ZN3tao5pegtl8demangleINS0_3repILj2EJNS0_5ascii6xdigitEEEEEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEv:
   35|    356|{
   36|    356|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    356|   constexpr auto begin = sv.find( '=' );
   38|    356|   static_assert( begin != std::string_view::npos );
   39|    356|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    356|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|    385|{
   36|    385|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    385|   constexpr auto begin = sv.find( '=' );
   38|    385|   static_assert( begin != std::string_view::npos );
   39|    385|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    385|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|  1.33k|{
   36|  1.33k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  1.33k|   constexpr auto begin = sv.find( '=' );
   38|  1.33k|   static_assert( begin != std::string_view::npos );
   39|  1.33k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  1.33k|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|     52|{
   36|     52|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|     52|   constexpr auto begin = sv.find( '=' );
   38|     52|   static_assert( begin != std::string_view::npos );
   39|     52|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|     52|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|    272|{
   36|    272|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    272|   constexpr auto begin = sv.find( '=' );
   38|    272|   static_assert( begin != std::string_view::npos );
   39|    272|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    272|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEEENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEEv:
   35|  4.31k|{
   36|  4.31k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  4.31k|   constexpr auto begin = sv.find( '=' );
   38|  4.31k|   static_assert( begin != std::string_view::npos );
   39|  4.31k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  4.31k|}

_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser10id_actionsEJNS4_14rule_attributeINS4_6str_idENS4_15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  44.1k|      {
   45|  44.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  44.1k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser12name_actionsEJNS4_14rule_attributeINS4_8str_nameENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  41.7k|      {
   45|  41.7k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  41.7k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser12hash_actionsEJNS4_14rule_attributeINS4_8str_hashENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  37.1k|      {
   45|  37.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  37.1k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser19parent_hash_actionsEJNS4_14rule_attributeINS4_15str_parent_hashENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  32.9k|      {
   45|  32.9k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  32.9k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser14serial_actionsEJNS4_14rule_attributeINS4_10str_serialENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  30.1k|      {
   45|  30.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  30.1k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser16via_port_actionsEJNS4_14rule_attributeINS4_12str_via_portENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  27.4k|      {
   45|  27.4k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  27.4k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser22with_interface_actionsEJNS4_14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  24.5k|      {
   45|  24.5k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  24.5k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser25with_connect_type_actionsEJNS4_14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  21.3k|      {
   45|  21.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  21.3k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser17condition_actionsEJNS4_14rule_attributeINS4_6str_ifENS4_9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  18.1k|      {
   45|  18.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  18.1k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser13label_actionsEJNS4_14rule_attributeINS4_9str_labelENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  11.9k|      {
   45|  11.9k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  11.9k|      }

_ZN3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEEC2ERKNS1_8iteratorERKSF_:
   29|  1.74M|      {}
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE6stringEv:
   75|  1.70M|      {
   76|  1.70M|         return std::string( begin(), size() );
   77|  1.70M|      }
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE5beginEv:
   50|  3.41M|      {
   51|  3.41M|         if constexpr( std::is_same_v< iterator_t, const char* > ) {
  ------------------
  |  Branch (51:24): [Folded - Ignored]
  ------------------
   52|  3.41M|            return iterator();
   53|  3.41M|         }
   54|  3.41M|         else {
   55|  3.41M|            return iterator().data;
   56|  3.41M|         }
   57|  3.41M|      }
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE8iteratorEv:
   40|  3.41M|      {
   41|  3.41M|         return m_begin;
   42|  3.41M|      }
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE4sizeEv:
   70|  1.70M|      {
   71|  1.70M|         return std::size_t( end() - begin() );
   72|  1.70M|      }
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE3endEv:
   60|  1.70M|      {
   61|  1.70M|         return input().current();
   62|  1.70M|      }
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE5inputEv:
   45|  1.70M|      {
   46|  1.70M|         return m_input;
   47|  1.70M|      }
_ZNK3tao5pegtl8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEE8positionEv:
   95|  2.05k|      {
   96|  2.05k|         return input().position( iterator() );  // NOTE: Not efficient with lazy inputs.
   97|  2.05k|      }

_ZN3tao5pegtl8internal3anyINS1_9peek_charEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   35|  1.15M|      {
   36|  1.15M|         if( !in.empty() ) {
  ------------------
  |  Branch (36:14): [True: 1.15M, False: 0]
  ------------------
   37|  1.15M|            in.bump();
   38|  1.15M|            return true;
   39|  1.15M|         }
   40|      0|         return false;
   41|  1.15M|      }

_ZN3tao5pegtl8internal4bumpERNS1_8iteratorEmi:
   14|  1.63M|   {
   15|  3.26M|      for( std::size_t i = 0; i < count; ++i ) {
  ------------------
  |  Branch (15:31): [True: 1.63M, False: 1.63M]
  ------------------
   16|  1.63M|         if( iter.data[ i ] == ch ) {
  ------------------
  |  Branch (16:14): [True: 15.6k, False: 1.61M]
  ------------------
   17|  15.6k|            ++iter.line;
   18|  15.6k|            iter.column = 1;
   19|  15.6k|         }
   20|  1.61M|         else {
   21|  1.61M|            ++iter.column;
   22|  1.61M|         }
   23|  1.63M|      }
   24|  1.63M|      iter.byte += count;
   25|  1.63M|      iter.data += count;
   26|  1.63M|   }
_ZN3tao5pegtl8internal17bump_in_this_lineERNS1_8iteratorEm:
   29|  97.2M|   {
   30|  97.2M|      iter.data += count;
   31|  97.2M|      iter.byte += count;
   32|  97.2M|      iter.column += count;
   33|  97.2M|   }

_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.86M|   {
   16|  1.86M|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  1.86M|         in.bump( count );
   18|  1.86M|      }
   19|  1.86M|      else {
   20|  1.86M|         in.bump_in_this_line( count );
   21|  1.86M|      }
   22|  1.86M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  14.0k|   {
   16|  14.0k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  14.0k|         in.bump( count );
   18|  14.0k|      }
   19|  14.0k|      else {
   20|  14.0k|         in.bump_in_this_line( count );
   21|  14.0k|      }
   22|  14.0k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc111ELc119EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  36.0k|   {
   16|  36.0k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  36.0k|         in.bump( count );
   18|  36.0k|      }
   19|  36.0k|      else {
   20|  36.0k|         in.bump_in_this_line( count );
   21|  36.0k|      }
   22|  36.0k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc98ELc108ELc111ELc99ELc107EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.99k|   {
   16|  3.99k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.99k|         in.bump( count );
   18|  3.99k|      }
   19|  3.99k|      else {
   20|  3.99k|         in.bump_in_this_line( count );
   21|  3.99k|      }
   22|  3.99k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|    264|   {
   16|    264|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|    264|         in.bump( count );
   18|    264|      }
   19|    264|      else {
   20|    264|         in.bump_in_this_line( count );
   21|    264|      }
   22|    264|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.66k|   {
   16|  2.66k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  2.66k|         in.bump( count );
   18|  2.66k|      }
   19|  2.66k|      else {
   20|  2.66k|         in.bump_in_this_line( count );
   21|  2.66k|      }
   22|  2.66k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|    508|   {
   16|    508|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|    508|         in.bump( count );
   18|    508|      }
   19|    508|      else {
   20|    508|         in.bump_in_this_line( count );
   21|    508|      }
   22|    508|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   867k|   {
   16|   867k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|   867k|         in.bump( count );
   18|   867k|      }
   19|   867k|      else {
   20|   867k|         in.bump_in_this_line( count );
   21|   867k|      }
   22|   867k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.64M|   {
   16|  1.64M|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  1.64M|         in.bump( count );
   18|  1.64M|      }
   19|  1.64M|      else {
   20|  1.64M|         in.bump_in_this_line( count );
   21|  1.64M|      }
   22|  1.64M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   948k|   {
   16|   948k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|   948k|         in.bump( count );
   18|   948k|      }
   19|   948k|      else {
   20|   948k|         in.bump_in_this_line( count );
   21|   948k|      }
   22|   948k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.83k|   {
   16|  2.83k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  2.83k|         in.bump( count );
   18|  2.83k|      }
   19|  2.83k|      else {
   20|  2.83k|         in.bump_in_this_line( count );
   21|  2.83k|      }
   22|  2.83k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.81k|   {
   16|  2.81k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  2.81k|         in.bump( count );
   18|  2.81k|      }
   19|  2.81k|      else {
   20|  2.81k|         in.bump_in_this_line( count );
   21|  2.81k|      }
   22|  2.81k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.56k|   {
   16|  2.56k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  2.56k|         in.bump( count );
   18|  2.56k|      }
   19|  2.56k|      else {
   20|  2.56k|         in.bump_in_this_line( count );
   21|  2.56k|      }
   22|  2.56k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.88k|   {
   16|  2.88k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  2.88k|         in.bump( count );
   18|  2.88k|      }
   19|  2.88k|      else {
   20|  2.88k|         in.bump_in_this_line( count );
   21|  2.88k|      }
   22|  2.88k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.56k|   {
   16|  2.56k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  2.56k|         in.bump( count );
   18|  2.56k|      }
   19|  2.56k|      else {
   20|  2.56k|         in.bump_in_this_line( count );
   21|  2.56k|      }
   22|  2.56k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.47k|   {
   16|  3.47k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.47k|         in.bump( count );
   18|  3.47k|      }
   19|  3.47k|      else {
   20|  3.47k|         in.bump_in_this_line( count );
   21|  3.47k|      }
   22|  3.47k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.99k|   {
   16|  1.99k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  1.99k|         in.bump( count );
   18|  1.99k|      }
   19|  1.99k|      else {
   20|  1.99k|         in.bump_in_this_line( count );
   21|  1.99k|      }
   22|  1.99k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  27.1k|   {
   16|  27.1k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  27.1k|         in.bump( count );
   18|  27.1k|      }
   19|  27.1k|      else {
   20|  27.1k|         in.bump_in_this_line( count );
   21|  27.1k|      }
   22|  27.1k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  23.7k|   {
   16|  23.7k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  23.7k|         in.bump( count );
   18|  23.7k|      }
   19|  23.7k|      else {
   20|  23.7k|         in.bump_in_this_line( count );
   21|  23.7k|      }
   22|  23.7k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc97ELc109ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.91k|   {
   16|  4.91k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  4.91k|         in.bump( count );
   18|  4.91k|      }
   19|  4.91k|      else {
   20|  4.91k|         in.bump_in_this_line( count );
   21|  4.91k|      }
   22|  4.91k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.04M|   {
   16|  1.04M|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  1.04M|         in.bump( count );
   18|  1.04M|      }
   19|  1.04M|      else {
   20|  1.04M|         in.bump_in_this_line( count );
   21|  1.04M|      }
   22|  1.04M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.07M|   {
   16|  1.07M|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  1.07M|         in.bump( count );
   18|  1.07M|      }
   19|  1.07M|      else {
   20|  1.07M|         in.bump_in_this_line( count );
   21|  1.07M|      }
   22|  1.07M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   287k|   {
   16|   287k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|   287k|         in.bump( count );
   18|   287k|      }
   19|   287k|      else {
   20|   287k|         in.bump_in_this_line( count );
   21|   287k|      }
   22|   287k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   483k|   {
   16|   483k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|   483k|         in.bump( count );
   18|   483k|      }
   19|   483k|      else {
   20|   483k|         in.bump_in_this_line( count );
   21|   483k|      }
   22|   483k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   479k|   {
   16|   479k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|   479k|         in.bump( count );
   18|   479k|      }
   19|   479k|      else {
   20|   479k|         in.bump_in_this_line( count );
   21|   479k|      }
   22|   479k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  76.1M|   {
   16|  76.1M|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  76.1M|         in.bump( count );
   18|  76.1M|      }
   19|  76.1M|      else {
   20|  76.1M|         in.bump_in_this_line( count );
   21|  76.1M|      }
   22|  76.1M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.55k|   {
   16|  4.55k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  4.55k|         in.bump( count );
   18|  4.55k|      }
   19|  4.55k|      else {
   20|  4.55k|         in.bump_in_this_line( count );
   21|  4.55k|      }
   22|  4.55k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.05k|   {
   16|  3.05k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.05k|         in.bump( count );
   18|  3.05k|      }
   19|  3.05k|      else {
   20|  3.05k|         in.bump_in_this_line( count );
   21|  3.05k|      }
   22|  3.05k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.03k|   {
   16|  3.03k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.03k|         in.bump( count );
   18|  3.03k|      }
   19|  3.03k|      else {
   20|  3.03k|         in.bump_in_this_line( count );
   21|  3.03k|      }
   22|  3.03k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.16k|   {
   16|  3.16k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.16k|         in.bump( count );
   18|  3.16k|      }
   19|  3.16k|      else {
   20|  3.16k|         in.bump_in_this_line( count );
   21|  3.16k|      }
   22|  3.16k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.60k|   {
   16|  3.60k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.60k|         in.bump( count );
   18|  3.60k|      }
   19|  3.60k|      else {
   20|  3.60k|         in.bump_in_this_line( count );
   21|  3.60k|      }
   22|  3.60k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.52k|   {
   16|  3.52k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  3.52k|         in.bump( count );
   18|  3.52k|      }
   19|  3.52k|      else {
   20|  3.52k|         in.bump_in_this_line( count );
   21|  3.52k|      }
   22|  3.52k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  6.79k|   {
   16|  6.79k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  6.79k|         in.bump( count );
   18|  6.79k|      }
   19|  6.79k|      else {
   20|  6.79k|         in.bump_in_this_line( count );
   21|  6.79k|      }
   22|  6.79k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.24k|   {
   16|  1.24k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  1.24k|         in.bump( count );
   18|  1.24k|      }
   19|  1.24k|      else {
   20|  1.24k|         in.bump_in_this_line( count );
   21|  1.24k|      }
   22|  1.24k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   290k|   {
   16|   290k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|   290k|         in.bump( count );
   18|   290k|      }
   19|   290k|      else {
   20|   290k|         in.bump_in_this_line( count );
   21|   290k|      }
   22|   290k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  12.3M|   {
   16|  12.3M|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  12.3M|         in.bump( count );
   18|  12.3M|      }
   19|  12.3M|      else {
   20|  12.3M|         in.bump_in_this_line( count );
   21|  12.3M|      }
   22|  12.3M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  35.6k|   {
   16|  35.6k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  35.6k|         in.bump( count );
   18|  35.6k|      }
   19|  35.6k|      else {
   20|  35.6k|         in.bump_in_this_line( count );
   21|  35.6k|      }
   22|  35.6k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  35.6k|   {
   16|  35.6k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  35.6k|         in.bump( count );
   18|  35.6k|      }
   19|  35.6k|      else {
   20|  35.6k|         in.bump_in_this_line( count );
   21|  35.6k|      }
   22|  35.6k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc108ELc97ELc98ELc101ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.36k|   {
   16|  4.36k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
  ------------------
  |  Branch (16:21): [Folded - Ignored]
  ------------------
   17|  4.36k|         in.bump( count );
   18|  4.36k|      }
   19|  4.36k|      else {
   20|  4.36k|         in.bump_in_this_line( count );
   21|  4.36k|      }
   22|  4.36k|   }

_ZN3tao5pegtl8internal3eof5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEEEEEbRT_:
   22|  1.24M|      {
   23|  1.24M|         return in.empty();
   24|  1.24M|      }

_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSI_4RuleEEEEbRT3_DpOT4_:
   37|  86.7k|      {
   38|  86.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 14.0k, False: 72.7k]
  ------------------
   39|  14.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  14.0k|            return true;
   41|  14.0k|         }
   42|  72.7k|         return Default;
   43|  86.7k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|   484k|      {
   38|   484k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 482k, False: 1.38k]
  ------------------
   39|   482k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   482k|            return true;
   41|   482k|         }
   42|  1.38k|         return Default;
   43|   484k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  9.12M|      {
   38|  9.12M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 165k, False: 8.95M]
  ------------------
   39|   165k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   165k|            return true;
   41|   165k|         }
   42|  8.95M|         return Default;
   43|  9.12M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   165k|      {
   38|   165k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 47.9k, False: 117k]
  ------------------
   39|  47.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  47.9k|            return true;
   41|  47.9k|         }
   42|   117k|         return Default;
   43|   165k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|   117k|      {
   38|   117k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 50.4k, False: 67.5k]
  ------------------
   39|  50.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  50.4k|            return true;
   41|  50.4k|         }
   42|  67.5k|         return Default;
   43|   117k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  11.1k|      {
   38|  11.1k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 9.98k, False: 1.12k]
  ------------------
   39|  9.98k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  9.98k|            return true;
   41|  9.98k|         }
   42|  1.12k|         return Default;
   43|  11.1k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  9.70M|      {
   38|  9.70M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 107k, False: 9.59M]
  ------------------
   39|   107k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   107k|            return true;
   41|   107k|         }
   42|  9.59M|         return Default;
   43|  9.70M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   107k|      {
   38|   107k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 39.3k, False: 67.9k]
  ------------------
   39|  39.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  39.3k|            return true;
   41|  39.3k|         }
   42|  67.9k|         return Default;
   43|   107k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  67.9k|      {
   38|  67.9k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 23.2k, False: 44.7k]
  ------------------
   39|  23.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  23.2k|            return true;
   41|  23.2k|         }
   42|  44.7k|         return Default;
   43|  67.9k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.33k|      {
   38|  6.33k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.65k, False: 680]
  ------------------
   39|  5.65k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.65k|            return true;
   41|  5.65k|         }
   42|    680|         return Default;
   43|  6.33k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.29M|      {
   38|  6.29M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 97.4k, False: 6.20M]
  ------------------
   39|  97.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  97.4k|            return true;
   41|  97.4k|         }
   42|  6.20M|         return Default;
   43|  6.29M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|  97.4k|      {
   38|  97.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 41.5k, False: 55.9k]
  ------------------
   39|  41.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  41.5k|            return true;
   41|  41.5k|         }
   42|  55.9k|         return Default;
   43|  97.4k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  55.9k|      {
   38|  55.9k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 19.5k, False: 36.4k]
  ------------------
   39|  19.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  19.5k|            return true;
   41|  19.5k|         }
   42|  36.4k|         return Default;
   43|  55.9k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  5.59k|      {
   38|  5.59k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.64k, False: 944]
  ------------------
   39|  4.64k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.64k|            return true;
   41|  4.64k|         }
   42|    944|         return Default;
   43|  5.59k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.34M|      {
   38|  7.34M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 151k, False: 7.19M]
  ------------------
   39|   151k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   151k|            return true;
   41|   151k|         }
   42|  7.19M|         return Default;
   43|  7.34M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   151k|      {
   38|   151k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 37.9k, False: 113k]
  ------------------
   39|  37.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  37.9k|            return true;
   41|  37.9k|         }
   42|   113k|         return Default;
   43|   151k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|   113k|      {
   38|   113k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 42.2k, False: 70.8k]
  ------------------
   39|  42.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  42.2k|            return true;
   41|  42.2k|         }
   42|  70.8k|         return Default;
   43|   113k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  5.71k|      {
   38|  5.71k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.75k, False: 960]
  ------------------
   39|  4.75k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.75k|            return true;
   41|  4.75k|         }
   42|    960|         return Default;
   43|  5.71k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.87M|      {
   38|  7.87M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 156k, False: 7.71M]
  ------------------
   39|   156k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   156k|            return true;
   41|   156k|         }
   42|  7.71M|         return Default;
   43|  7.87M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   156k|      {
   38|   156k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 28.6k, False: 128k]
  ------------------
   39|  28.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  28.6k|            return true;
   41|  28.6k|         }
   42|   128k|         return Default;
   43|   156k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|   128k|      {
   38|   128k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 47.2k, False: 80.8k]
  ------------------
   39|  47.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  47.2k|            return true;
   41|  47.2k|         }
   42|  80.8k|         return Default;
   43|   128k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.52k|      {
   38|  6.52k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.15k, False: 1.37k]
  ------------------
   39|  5.15k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.15k|            return true;
   41|  5.15k|         }
   42|  1.37k|         return Default;
   43|  6.52k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  5.66M|      {
   38|  5.66M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 116k, False: 5.54M]
  ------------------
   39|   116k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   116k|            return true;
   41|   116k|         }
   42|  5.54M|         return Default;
   43|  5.66M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   116k|      {
   38|   116k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.9k, False: 85.8k]
  ------------------
   39|  30.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.9k|            return true;
   41|  30.9k|         }
   42|  85.8k|         return Default;
   43|   116k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  85.8k|      {
   38|  85.8k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 33.7k, False: 52.1k]
  ------------------
   39|  33.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  33.7k|            return true;
   41|  33.7k|         }
   42|  52.1k|         return Default;
   43|  85.8k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc40EEEEJNS0_5untilINS4_IJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   37|   290k|      {
   38|   290k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 35.6k, False: 254k]
  ------------------
   39|  35.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  35.6k|            return true;
   41|  35.6k|         }
   42|   254k|         return Default;
   43|   290k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc41EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  23.8M|      {
   38|  23.8M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 155k, False: 23.7M]
  ------------------
   39|   155k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   155k|            return true;
   41|   155k|         }
   42|  23.7M|         return Default;
   43|  23.8M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   155k|      {
   38|   155k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.6k, False: 124k]
  ------------------
   39|  30.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.6k|            return true;
   41|  30.6k|         }
   42|   124k|         return Default;
   43|   155k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|   124k|      {
   38|   124k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 45.0k, False: 79.9k]
  ------------------
   39|  45.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  45.0k|            return true;
   41|  45.0k|         }
   42|  79.9k|         return Default;
   43|   124k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.56k|      {
   38|  7.56k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.50k, False: 1.05k]
  ------------------
   39|  6.50k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.50k|            return true;
   41|  6.50k|         }
   42|  1.05k|         return Default;
   43|  7.56k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.34M|      {
   38|  7.34M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 121k, False: 7.22M]
  ------------------
   39|   121k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   121k|            return true;
   41|   121k|         }
   42|  7.22M|         return Default;
   43|  7.34M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   121k|      {
   38|   121k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.3k, False: 90.7k]
  ------------------
   39|  30.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.3k|            return true;
   41|  30.3k|         }
   42|  90.7k|         return Default;
   43|   121k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  90.7k|      {
   38|  90.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 33.3k, False: 57.3k]
  ------------------
   39|  33.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  33.3k|            return true;
   41|  33.3k|         }
   42|  57.3k|         return Default;
   43|  90.7k|      }

_ZNK3tao5pegtl8internal10input_pairIcEcvbEv:
   22|   257M|      {
   23|   257M|         return size > 0;
   24|   257M|      }

_ZN3tao5pegtl8internal8iteratorC2EPKc:
   20|  38.3k|      {}

_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEC2ERKS3_:
   19|   429M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEC2ERS3_:
   44|  8.33M|      {}
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EE8iteratorEv:
   69|  1.74M|      {
   70|  1.74M|         return m_saved;
   71|  1.74M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEC2ERKS3_:
   19|  1.65M|      {}
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEclEb:
   30|  1.64M|      {
   31|  1.64M|         return result;
   32|  1.64M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEclEb:
   60|  5.46M|      {
   61|  5.46M|         if( result ) {
  ------------------
  |  Branch (61:14): [True: 4.67M, False: 794k]
  ------------------
   62|  4.67M|            m_input = nullptr;
   63|  4.67M|            return true;
   64|  4.67M|         }
   65|   794k|         return false;
   66|  5.46M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EED2Ev:
   50|  8.33M|      {
   51|  8.33M|         if( m_input != nullptr ) {
  ------------------
  |  Branch (51:14): [True: 3.66M, False: 4.67M]
  ------------------
   52|  3.66M|            ( *m_input ) = m_saved;
   53|  3.66M|         }
   54|  8.33M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEclEb:
   30|   429M|      {
   31|   429M|         return result;
   32|   429M|      }

_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|  47.7k|      {
   56|  47.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 4.31k, False: 43.4k]
  ------------------
   57|  4.31k|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|  4.31k|         }
   59|  47.7k|         return true;
   60|  47.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEbRT3_DpOT4_:
   55|  14.0k|      {
   56|  14.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 14.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  14.0k|         return true;
   60|  14.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|   482k|      {
   56|   482k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 191, False: 482k]
  ------------------
   57|    191|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    191|         }
   59|   482k|         return true;
   60|   482k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   165k|      {
   56|   165k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 68, False: 165k]
  ------------------
   57|     68|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     68|         }
   59|   165k|         return true;
   60|   165k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  47.9k|      {
   56|  47.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 52, False: 47.8k]
  ------------------
   57|     52|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     52|         }
   59|  47.9k|         return true;
   60|  47.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  50.4k|      {
   56|  50.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 50.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  50.4k|         return true;
   60|  50.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  9.98k|      {
   56|  9.98k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 196, False: 9.79k]
  ------------------
   57|    196|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    196|         }
   59|  9.98k|         return true;
   60|  9.98k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   107k|      {
   56|   107k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 61, False: 107k]
  ------------------
   57|     61|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     61|         }
   59|   107k|         return true;
   60|   107k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  39.3k|      {
   56|  39.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 46, False: 39.2k]
  ------------------
   57|     46|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     46|         }
   59|  39.3k|         return true;
   60|  39.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  23.2k|      {
   56|  23.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 23.2k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  23.2k|         return true;
   60|  23.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.65k|      {
   56|  5.65k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 175, False: 5.47k]
  ------------------
   57|    175|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    175|         }
   59|  5.65k|         return true;
   60|  5.65k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|  97.4k|      {
   56|  97.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 37, False: 97.4k]
  ------------------
   57|     37|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     37|         }
   59|  97.4k|         return true;
   60|  97.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  41.5k|      {
   56|  41.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 33, False: 41.4k]
  ------------------
   57|     33|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     33|         }
   59|  41.5k|         return true;
   60|  41.5k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  19.5k|      {
   56|  19.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 19.5k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  19.5k|         return true;
   60|  19.5k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  4.64k|      {
   56|  4.64k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 193, False: 4.45k]
  ------------------
   57|    193|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    193|         }
   59|  4.64k|         return true;
   60|  4.64k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   151k|      {
   56|   151k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 52, False: 150k]
  ------------------
   57|     52|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     52|         }
   59|   151k|         return true;
   60|   151k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  37.9k|      {
   56|  37.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 41, False: 37.9k]
  ------------------
   57|     41|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     41|         }
   59|  37.9k|         return true;
   60|  37.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  42.2k|      {
   56|  42.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 42.2k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  42.2k|         return true;
   60|  42.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  4.75k|      {
   56|  4.75k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 197, False: 4.56k]
  ------------------
   57|    197|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    197|         }
   59|  4.75k|         return true;
   60|  4.75k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   156k|      {
   56|   156k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 52, False: 156k]
  ------------------
   57|     52|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     52|         }
   59|   156k|         return true;
   60|   156k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  28.6k|      {
   56|  28.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 49, False: 28.6k]
  ------------------
   57|     49|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     49|         }
   59|  28.6k|         return true;
   60|  28.6k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  47.2k|      {
   56|  47.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 47.2k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  47.2k|         return true;
   60|  47.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.15k|      {
   56|  5.15k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 191, False: 4.96k]
  ------------------
   57|    191|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    191|         }
   59|  5.15k|         return true;
   60|  5.15k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   116k|      {
   56|   116k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 53, False: 116k]
  ------------------
   57|     53|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     53|         }
   59|   116k|         return true;
   60|   116k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  30.9k|      {
   56|  30.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 55, False: 30.8k]
  ------------------
   57|     55|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     55|         }
   59|  30.9k|         return true;
   60|  30.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  33.7k|      {
   56|  33.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 33.7k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  33.7k|         return true;
   60|  33.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  35.6k|      {
   56|  35.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 272, False: 35.4k]
  ------------------
   57|    272|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    272|         }
   59|  35.6k|         return true;
   60|  35.6k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   155k|      {
   56|   155k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 52, False: 155k]
  ------------------
   57|     52|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     52|         }
   59|   155k|         return true;
   60|   155k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  30.6k|      {
   56|  30.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 42, False: 30.6k]
  ------------------
   57|     42|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     42|         }
   59|  30.6k|         return true;
   60|  30.6k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  45.0k|      {
   56|  45.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 45.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  45.0k|         return true;
   60|  45.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS8_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.50k|      {
   56|  6.50k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 195, False: 6.31k]
  ------------------
   57|    195|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    195|         }
   59|  6.50k|         return true;
   60|  6.50k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   121k|      {
   56|   121k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 62, False: 120k]
  ------------------
   57|     62|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     62|         }
   59|   121k|         return true;
   60|   121k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  30.3k|      {
   56|  30.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 38, False: 30.2k]
  ------------------
   57|     38|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     38|         }
   59|  30.3k|         return true;
   60|  30.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  33.3k|      {
   56|  33.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 33.3k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  33.3k|         return true;
   60|  33.3k|      }

_ZN3tao5pegtl8internal6not_atIJNS0_3eofEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   44|  1.16M|      {
   45|  1.16M|         const auto m = in.template mark< rewind_mode::required >();
   46|  1.16M|         return !Control< Rule >::template match< apply_mode::nothing, rewind_mode::active, Action, Control >( in, st... );
   47|  1.16M|      }

_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  3.81M|      {
   41|  3.81M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 3.77M, False: 34.6k]
  ------------------
   42|  3.77M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.86M, False: 1.91M]
  ------------------
   43|  1.86M|               bump_help< one >( in, t.size );
   44|  1.86M|               return true;
   45|  1.86M|            }
   46|  3.77M|         }
   47|  1.94M|         return false;
   48|  3.81M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE4testEc:
   31|  3.77M|      {
   32|  5.75M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 1.79M, False: 1.97M]
  |  Branch (32:19): [True: 67.6k, False: 1.91M]
  ------------------
   33|  3.77M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  86.7k|      {
   41|  86.7k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 71.0k, False: 15.7k]
  ------------------
   42|  71.0k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 14.0k, False: 57.0k]
  ------------------
   43|  14.0k|               bump_help< one >( in, t.size );
   44|  14.0k|               return true;
   45|  14.0k|            }
   46|  71.0k|         }
   47|  72.7k|         return false;
   48|  86.7k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE4testEc:
   31|  71.0k|      {
   32|  71.0k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  71.0k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.68M|      {
   41|  1.68M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.68M, False: 157]
  ------------------
   42|  1.68M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.64M, False: 38.8k]
  ------------------
   43|  1.64M|               bump_help< one >( in, t.size );
   44|  1.64M|               return true;
   45|  1.64M|            }
   46|  1.68M|         }
   47|  39.0k|         return false;
   48|  1.68M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE4testEc:
   31|  1.68M|      {
   32|  1.68M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.68M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   948k|      {
   41|   948k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 948k, False: 46]
  ------------------
   42|   948k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 948k, False: 82]
  ------------------
   43|   948k|               bump_help< one >( in, t.size );
   44|   948k|               return true;
   45|   948k|            }
   46|   948k|         }
   47|    128|         return false;
   48|   948k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE4testEc:
   31|   948k|      {
   32|   948k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   948k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  39.6k|      {
   41|  39.6k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 39.2k, False: 385]
  ------------------
   42|  39.2k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 27.1k, False: 12.1k]
  ------------------
   43|  27.1k|               bump_help< one >( in, t.size );
   44|  27.1k|               return true;
   45|  27.1k|            }
   46|  39.2k|         }
   47|  12.4k|         return false;
   48|  39.6k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE4testEc:
   31|  39.2k|      {
   32|  39.2k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  39.2k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  25.4k|      {
   41|  25.4k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 24.4k, False: 985]
  ------------------
   42|  24.4k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 23.7k, False: 672]
  ------------------
   43|  23.7k|               bump_help< one >( in, t.size );
   44|  23.7k|               return true;
   45|  23.7k|            }
   46|  24.4k|         }
   47|  1.65k|         return false;
   48|  25.4k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE4testEc:
   31|  24.4k|      {
   32|  24.4k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  24.4k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  54.4M|      {
   41|  54.4M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 54.4M, False: 1.93k]
  ------------------
   42|  54.4M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.04M, False: 53.3M]
  ------------------
   43|  1.04M|               bump_help< one >( in, t.size );
   44|  1.04M|               return true;
   45|  1.04M|            }
   46|  54.4M|         }
   47|  53.3M|         return false;
   48|  54.4M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE4testEc:
   31|  54.4M|      {
   32|  54.4M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  54.4M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  77.2M|      {
   41|  77.2M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 77.2M, False: 1.57k]
  ------------------
   42|  77.2M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.07M, False: 76.1M]
  ------------------
   43|  1.07M|               bump_help< one >( in, t.size );
   44|  1.07M|               return true;
   45|  1.07M|            }
   46|  77.2M|         }
   47|  76.1M|         return false;
   48|  77.2M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE4testEc:
   31|  77.2M|      {
   32|  77.2M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  77.2M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.07M|      {
   41|  1.07M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.07M, False: 123]
  ------------------
   42|  1.07M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 287k, False: 784k]
  ------------------
   43|   287k|               bump_help< one >( in, t.size );
   44|   287k|               return true;
   45|   287k|            }
   46|  1.07M|         }
   47|   784k|         return false;
   48|  1.07M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE4testEc:
   31|  1.07M|      {
   32|  1.07M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.07M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   489k|      {
   41|   489k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 489k, False: 123]
  ------------------
   42|   489k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 479k, False: 9.73k]
  ------------------
   43|   479k|               bump_help< one >( in, t.size );
   44|   479k|               return true;
   45|   479k|            }
   46|   489k|         }
   47|  9.85k|         return false;
   48|   489k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE4testEc:
   31|   489k|      {
   32|  4.30M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 0, False: 24.5k]
  |  Branch (32:19): [True: 14.7k, False: 9.73k]
  |  Branch (32:19): [True: 43.8k, False: 24.5k]
  |  Branch (32:19): [True: 84.0k, False: 68.3k]
  |  Branch (32:19): [True: 12.8k, False: 152k]
  |  Branch (32:19): [True: 31.1k, False: 165k]
  |  Branch (32:19): [True: 41.4k, False: 196k]
  |  Branch (32:19): [True: 26.4k, False: 237k]
  |  Branch (32:19): [True: 85.1k, False: 264k]
  |  Branch (32:19): [True: 89.2k, False: 349k]
  |  Branch (32:19): [True: 51.0k, False: 438k]
  ------------------
   33|   489k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  76.1M|      {
   41|  76.1M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 76.1M, False: 1.57k]
  ------------------
   42|  76.1M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 76.1M, False: 39]
  ------------------
   43|  76.1M|               bump_help< one >( in, t.size );
   44|  76.1M|               return true;
   45|  76.1M|            }
   46|  76.1M|         }
   47|  1.61k|         return false;
   48|  76.1M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE4testEc:
   31|  76.1M|      {
   32|   152M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 15, False: 76.1M]
  |  Branch (32:19): [True: 24, False: 76.1M]
  ------------------
   33|  76.1M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   291k|      {
   41|   291k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 291k, False: 124]
  ------------------
   42|   291k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.24k, False: 290k]
  ------------------
   43|  1.24k|               bump_help< one >( in, t.size );
   44|  1.24k|               return true;
   45|  1.24k|            }
   46|   291k|         }
   47|   290k|         return false;
   48|   291k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE4testEc:
   31|   291k|      {
   32|   291k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   291k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   290k|      {
   41|   290k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 289k, False: 900]
  ------------------
   42|   289k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 35.6k, False: 253k]
  ------------------
   43|  35.6k|               bump_help< one >( in, t.size );
   44|  35.6k|               return true;
   45|  35.6k|            }
   46|   289k|         }
   47|   254k|         return false;
   48|   290k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE4testEc:
   31|   289k|      {
   32|   289k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   289k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  23.9M|      {
   41|  23.9M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 23.9M, False: 277]
  ------------------
   42|  23.9M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 35.6k, False: 23.8M]
  ------------------
   43|  35.6k|               bump_help< one >( in, t.size );
   44|  35.6k|               return true;
   45|  35.6k|            }
   46|  23.9M|         }
   47|  23.8M|         return false;
   48|  23.9M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE4testEc:
   31|  23.9M|      {
   32|  23.9M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  23.9M|      }

_ZN3tao5pegtl8internal3optIJNS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   46|  43.4k|      {
   47|  43.4k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  43.4k|         return true;
   49|  43.4k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENSA_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   46|  43.4k|      {
   47|  43.4k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  43.4k|         return true;
   49|  43.4k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  2.81k|      {
   47|  2.81k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  2.81k|         return true;
   49|  2.81k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.89k|      {
   47|  4.89k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.89k|         return true;
   49|  4.89k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.53k|      {
   47|  4.53k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.53k|         return true;
   49|  4.53k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.04k|      {
   47|  3.04k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.04k|         return true;
   49|  3.04k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.01k|      {
   47|  3.01k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.01k|         return true;
   49|  3.01k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.15k|      {
   47|  3.15k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.15k|         return true;
   49|  3.15k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.58k|      {
   47|  3.58k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.58k|         return true;
   49|  3.58k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.50k|      {
   47|  3.50k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.50k|         return true;
   49|  3.50k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  6.76k|      {
   47|  6.76k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  6.76k|         return true;
   49|  6.76k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser8negationEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   291k|      {
   47|   291k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   291k|         return true;
   49|   291k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser18condition_argumentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   290k|      {
   47|   290k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   290k|         return true;
   49|   290k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.34k|      {
   47|  4.34k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.34k|         return true;
   49|  4.34k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser7commentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|  38.9k|      {
   47|  38.9k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.9k|         return true;
   49|  38.9k|      }

_ZN3tao5pegtl8internal9peek_char4peekINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEEEEENS1_10input_pairIcEERT_:
   22|   257M|      {
   23|   257M|         if( in.empty() ) {
  ------------------
  |  Branch (23:14): [True: 60.3k, False: 257M]
  ------------------
   24|  60.3k|            return { 0, 0 };
   25|  60.3k|         }
   26|   257M|         return { in.peek_char(), 1 };
   27|   257M|      }

_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   118k|      {
   46|   118k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 84.6k, False: 33.9k]
  ------------------
   47|  87.0k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.41k, False: 84.6k]
  ------------------
   48|  2.41k|            }
   49|  84.6k|            return true;
   50|  84.6k|         }
   51|  33.9k|         return false;
   52|   118k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   728k|      {
   46|   728k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 726k, False: 1.46k]
  ------------------
   47|   730k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.50k, False: 726k]
  ------------------
   48|  3.50k|            }
   49|   726k|            return true;
   50|   726k|         }
   51|  1.46k|         return false;
   52|   728k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   488k|      {
   46|   488k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 486k, False: 2.29k]
  ------------------
   47|   497k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 11.1k, False: 486k]
  ------------------
   48|  11.1k|            }
   49|   486k|            return true;
   50|   486k|         }
   51|  2.29k|         return false;
   52|   488k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  15.6k|      {
   46|  15.6k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 12.9k, False: 2.64k]
  ------------------
   47|  15.1k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.15k, False: 12.9k]
  ------------------
   48|  2.15k|            }
   49|  12.9k|            return true;
   50|  12.9k|         }
   51|  2.64k|         return false;
   52|  15.6k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.44k|      {
   46|  9.44k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.60k, False: 1.83k]
  ------------------
   47|  10.7k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.13k, False: 7.60k]
  ------------------
   48|  3.13k|            }
   49|  7.60k|            return true;
   50|  7.60k|         }
   51|  1.83k|         return false;
   52|  9.44k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  7.49k|      {
   46|  7.49k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.41k, False: 1.07k]
  ------------------
   47|  8.34k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.92k, False: 6.41k]
  ------------------
   48|  1.92k|            }
   49|  6.41k|            return true;
   50|  6.41k|         }
   51|  1.07k|         return false;
   52|  7.49k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.29k|      {
   46|  8.29k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.90k, False: 1.39k]
  ------------------
   47|  9.41k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.51k, False: 6.90k]
  ------------------
   48|  2.51k|            }
   49|  6.90k|            return true;
   50|  6.90k|         }
   51|  1.39k|         return false;
   52|  8.29k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   115k|      {
   46|   115k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 113k, False: 1.63k]
  ------------------
   47|   122k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 8.72k, False: 113k]
  ------------------
   48|  8.72k|            }
   49|   113k|            return true;
   50|   113k|         }
   51|  1.63k|         return false;
   52|   115k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.44k|      {
   46|  9.44k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.79k, False: 1.65k]
  ------------------
   47|  10.4k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.61k, False: 7.79k]
  ------------------
   48|  2.61k|            }
   49|  7.79k|            return true;
   50|  7.79k|         }
   51|  1.65k|         return false;
   52|  9.44k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   295k|      {
   46|   295k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 293k, False: 2.46k]
  ------------------
   47|   312k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 19.3k, False: 293k]
  ------------------
   48|  19.3k|            }
   49|   293k|            return true;
   50|   293k|         }
   51|  2.46k|         return false;
   52|   295k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  10.5k|      {
   46|  10.5k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 8.99k, False: 1.60k]
  ------------------
   47|  14.9k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 6.00k, False: 8.99k]
  ------------------
   48|  6.00k|            }
   49|  8.99k|            return true;
   50|  8.99k|         }
   51|  1.60k|         return false;
   52|  10.5k|      }

_ZN3tao5pegtl8internal5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   39|  1.20M|      {
   40|  1.20M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (40:25): [True: 1.20M, False: 232]
  ------------------
   41|  1.20M|            if( test( t.data ) ) {
  ------------------
  |  Branch (41:17): [True: 483k, False: 717k]
  ------------------
   42|   483k|               bump_help< range >( in, t.size );
   43|   483k|               return true;
   44|   483k|            }
   45|  1.20M|         }
   46|   717k|         return false;
   47|  1.20M|      }
_ZN3tao5pegtl8internal5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EE4testEc:
   30|  1.20M|      {
   31|  1.20M|         return ( ( Lo <= c ) && ( c <= Hi ) ) == bool( R );
  ------------------
  |  Branch (31:19): [True: 1.00M, False: 196k]
  |  Branch (31:34): [True: 483k, False: 520k]
  ------------------
   32|  1.20M|      }

_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  2.55M|      {
   60|  2.55M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 2.55M, False: 471]
  ------------------
   61|  2.55M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 867k, False: 1.68M]
  ------------------
   62|   867k|               bump_help< ranges >( in, t.size );
   63|   867k|               return true;
   64|   867k|            }
   65|  2.55M|         }
   66|  1.68M|         return false;
   67|  2.55M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testEc:
   50|  2.55M|      {
   51|  2.55M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  2.55M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  2.55M|      {
   40|  2.55M|         constexpr const data_t cs[] = { Cs... };
   41|  2.55M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
  ------------------
  |  Branch (41:24): [Folded - Ignored]
  ------------------
   42|  9.38M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
  ------------------
  |  Branch (42:22): [True: 260k, False: 2.10M]
  |  Branch (42:22): [True: 419k, False: 1.68M]
  |  Branch (42:22): [True: 187k, False: 2.36M]
  ------------------
   43|  2.55M|         }
   44|  2.55M|         else {
   45|  2.55M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
   46|  2.55M|         }
   47|  2.55M|      }
_ZN3tao5pegtl8internal14validate_rangeIcLc48ELc57EEEbT_:
   23|  2.88M|   {
   24|  2.88M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.88M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 920k, False: 1.96M]
  |  Branch (25:29): [True: 199k, False: 720k]
  ------------------
   26|  2.88M|   }
_ZN3tao5pegtl8internal14validate_rangeIcLc97ELc102EEEbT_:
   23|  2.36M|   {
   24|  2.36M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.36M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 298k, False: 2.06M]
  |  Branch (25:29): [True: 260k, False: 38.3k]
  ------------------
   26|  2.36M|   }
_ZN3tao5pegtl8internal14validate_rangeIcLc65ELc70EEEbT_:
   23|  2.10M|   {
   24|  2.10M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.10M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 458k, False: 1.64M]
  |  Branch (25:29): [True: 419k, False: 38.3k]
  ------------------
   26|  2.10M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|   291k|      {
   60|   291k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 291k, False: 130]
  ------------------
   61|   291k|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 290k, False: 1.43k]
  ------------------
   62|   290k|               bump_help< ranges >( in, t.size );
   63|   290k|               return true;
   64|   290k|            }
   65|   291k|         }
   66|  1.56k|         return false;
   67|   291k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testEc:
   50|   291k|      {
   51|   291k|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|   291k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testIJLm0ELm1EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|   291k|      {
   40|   291k|         constexpr const data_t cs[] = { Cs... };
   41|   291k|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
  ------------------
  |  Branch (41:24): [Folded - Ignored]
  ------------------
   42|   291k|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
   43|   291k|         }
   44|   291k|         else {
   45|   585k|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 290k, False: 1.49k]
  |  Branch (45:22): [True: 42, False: 1.45k]
  |  Branch (45:96): [True: 15, False: 1.43k]
  ------------------
   46|   291k|         }
   47|   291k|      }
_ZN3tao5pegtl8internal14validate_rangeIcLc97ELc122EEEbT_:
   23|  12.9M|   {
   24|  12.9M|      static_assert( Lo <= Hi, "invalid range" );
   25|  12.9M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 7.30M, False: 5.63M]
  |  Branch (25:29): [True: 7.29M, False: 3.29k]
  ------------------
   26|  12.9M|   }
_ZN3tao5pegtl8internal14validate_rangeIcLc65ELc90EEEbT_:
   23|  5.64M|   {
   24|  5.64M|      static_assert( Lo <= Hi, "invalid range" );
   25|  5.64M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 5.30M, False: 336k]
  |  Branch (25:29): [True: 5.30M, False: 3.31k]
  ------------------
   26|  5.64M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  12.6M|      {
   60|  12.6M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 12.6M, False: 900]
  ------------------
   61|  12.6M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 12.3M, False: 289k]
  ------------------
   62|  12.3M|               bump_help< ranges >( in, t.size );
   63|  12.3M|               return true;
   64|  12.3M|            }
   65|  12.6M|         }
   66|   290k|         return false;
   67|  12.6M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testEc:
   50|  12.6M|      {
   51|  12.6M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  12.6M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  12.6M|      {
   40|  12.6M|         constexpr const data_t cs[] = { Cs... };
   41|  12.6M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
  ------------------
  |  Branch (41:24): [Folded - Ignored]
  ------------------
   42|  12.6M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
   43|  12.6M|         }
   44|  12.6M|         else {
   45|  36.9M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 5.30M, False: 338k]
  |  Branch (45:22): [True: 12.6k, False: 326k]
  |  Branch (45:22): [True: 7.00M, False: 5.64M]
  |  Branch (45:96): [True: 36.5k, False: 289k]
  ------------------
   46|  12.6M|         }
   47|  12.6M|      }

_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  43.3k|      {
   50|  43.3k|         auto m = in.template mark< M >();
   51|  43.3k|         using m_t = decltype( m );
   52|       |
   53|  51.9k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 49.8k, False: 2.13k]
  ------------------
   54|  49.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41.2k, False: 8.57k]
  ------------------
   55|  41.2k|               return false;
   56|  41.2k|            }
   57|  49.8k|         }
   58|  2.13k|         return m( true );
   59|  43.3k|      }
_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.45M|      {
   50|  1.45M|         auto m = in.template mark< M >();
   51|  1.45M|         using m_t = decltype( m );
   52|       |
   53|  1.45M|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 1.45M, False: 1.52k]
  ------------------
   54|  1.45M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.44M, False: 6.24k]
  ------------------
   55|  1.44M|               return false;
   56|  1.44M|            }
   57|  1.45M|         }
   58|  1.52k|         return m( true );
   59|  1.45M|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  47.9k|      {
   50|  47.9k|         auto m = in.template mark< M >();
   51|  47.9k|         using m_t = decltype( m );
   52|       |
   53|   143k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 95.8k, False: 47.8k]
  ------------------
   54|  95.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 52, False: 95.7k]
  ------------------
   55|     52|               return false;
   56|     52|            }
   57|  95.8k|         }
   58|  47.8k|         return m( true );
   59|  47.9k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  39.3k|      {
   50|  39.3k|         auto m = in.template mark< M >();
   51|  39.3k|         using m_t = decltype( m );
   52|       |
   53|   117k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 78.6k, False: 39.2k]
  ------------------
   54|  78.6k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 46, False: 78.5k]
  ------------------
   55|     46|               return false;
   56|     46|            }
   57|  78.6k|         }
   58|  39.2k|         return m( true );
   59|  39.3k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  41.5k|      {
   50|  41.5k|         auto m = in.template mark< M >();
   51|  41.5k|         using m_t = decltype( m );
   52|       |
   53|   124k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 82.9k, False: 41.4k]
  ------------------
   54|  82.9k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 33, False: 82.9k]
  ------------------
   55|     33|               return false;
   56|     33|            }
   57|  82.9k|         }
   58|  41.4k|         return m( true );
   59|  41.5k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  37.9k|      {
   50|  37.9k|         auto m = in.template mark< M >();
   51|  37.9k|         using m_t = decltype( m );
   52|       |
   53|   113k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 75.9k, False: 37.9k]
  ------------------
   54|  75.9k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41, False: 75.8k]
  ------------------
   55|     41|               return false;
   56|     41|            }
   57|  75.9k|         }
   58|  37.9k|         return m( true );
   59|  37.9k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  28.6k|      {
   50|  28.6k|         auto m = in.template mark< M >();
   51|  28.6k|         using m_t = decltype( m );
   52|       |
   53|  85.8k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 57.2k, False: 28.6k]
  ------------------
   54|  57.2k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 49, False: 57.2k]
  ------------------
   55|     49|               return false;
   56|     49|            }
   57|  57.2k|         }
   58|  28.6k|         return m( true );
   59|  28.6k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   111k|      {
   50|   111k|         auto m = in.template mark< M >();
   51|   111k|         using m_t = decltype( m );
   52|       |
   53|   333k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 222k, False: 110k]
  ------------------
   54|   222k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.33k, False: 221k]
  ------------------
   55|  1.33k|               return false;
   56|  1.33k|            }
   57|   222k|         }
   58|   110k|         return m( true );
   59|   111k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   221k|      {
   50|   221k|         auto m = in.template mark< M >();
   51|   221k|         using m_t = decltype( m );
   52|       |
   53|   278k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 249k, False: 28.4k]
  ------------------
   54|   249k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 192k, False: 56.9k]
  ------------------
   55|   192k|               return false;
   56|   192k|            }
   57|   249k|         }
   58|  28.4k|         return m( true );
   59|   221k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  30.9k|      {
   50|  30.9k|         auto m = in.template mark< M >();
   51|  30.9k|         using m_t = decltype( m );
   52|       |
   53|  92.7k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 61.8k, False: 30.8k]
  ------------------
   54|  61.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 55, False: 61.8k]
  ------------------
   55|     55|               return false;
   56|     55|            }
   57|  61.8k|         }
   58|  30.8k|         return m( true );
   59|  30.9k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  30.6k|      {
   50|  30.6k|         auto m = in.template mark< M >();
   51|  30.6k|         using m_t = decltype( m );
   52|       |
   53|  91.9k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 61.3k, False: 30.6k]
  ------------------
   54|  61.3k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 42, False: 61.3k]
  ------------------
   55|     42|               return false;
   56|     42|            }
   57|  61.3k|         }
   58|  30.6k|         return m( true );
   59|  30.6k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  30.3k|      {
   50|  30.3k|         auto m = in.template mark< M >();
   51|  30.3k|         using m_t = decltype( m );
   52|       |
   53|  90.8k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 60.6k, False: 30.2k]
  ------------------
   54|  60.6k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 38, False: 60.5k]
  ------------------
   55|     38|               return false;
   56|     38|            }
   57|  60.6k|         }
   58|  30.2k|         return m( true );
   59|  30.3k|      }

_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  50.4k|      {
   50|  86.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 75.9k, False: 10.7k]
  |  Branch (50:47): [True: 36.1k, False: 39.7k]
  ------------------
   51|  36.1k|         }
   52|  50.4k|         return true;
   53|  50.4k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  23.2k|      {
   50|  37.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 31.9k, False: 5.69k]
  |  Branch (50:47): [True: 14.4k, False: 17.5k]
  ------------------
   51|  14.4k|         }
   52|  23.2k|         return true;
   53|  23.2k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  19.5k|      {
   50|  40.0k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 31.1k, False: 8.88k]
  |  Branch (50:47): [True: 20.5k, False: 10.6k]
  ------------------
   51|  20.5k|         }
   52|  19.5k|         return true;
   53|  19.5k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  42.2k|      {
   50|  70.0k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 60.5k, False: 9.54k]
  |  Branch (50:47): [True: 27.7k, False: 32.7k]
  ------------------
   51|  27.7k|         }
   52|  42.2k|         return true;
   53|  42.2k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  47.2k|      {
   50|  73.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 64.3k, False: 9.34k]
  |  Branch (50:47): [True: 26.4k, False: 37.8k]
  ------------------
   51|  26.4k|         }
   52|  47.2k|         return true;
   53|  47.2k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  33.7k|      {
   50|  62.2k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 53.0k, False: 9.28k]
  |  Branch (50:47): [True: 28.5k, False: 24.4k]
  ------------------
   51|  28.5k|         }
   52|  33.7k|         return true;
   53|  33.7k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  45.0k|      {
   50|  56.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 52.2k, False: 4.50k]
  |  Branch (50:47): [True: 11.7k, False: 40.4k]
  ------------------
   51|  11.7k|         }
   52|  45.0k|         return true;
   53|  45.0k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  33.3k|      {
   50|  56.9k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 47.8k, False: 9.11k]
  |  Branch (50:47): [True: 23.5k, False: 24.2k]
  ------------------
   51|  23.5k|         }
   52|  33.3k|         return true;
   53|  33.3k|      }

_ZN3tao5pegtl8internal3seqIJNS0_4starINS0_5ascii5blankEJEEENS0_7if_mustINS4_3oneIJLc35EEEEJNS3_INS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS4_3anyEEEEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNSM_4RuleEEEEbRT3_DpOT4_:
   41|  86.7k|      {
   42|  86.7k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  86.7k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  86.7k|         }
   45|  86.7k|         else {
   46|  86.7k|            auto m = in.template mark< M >();
   47|  86.7k|            using m_t = decltype( m );
   48|   173k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 86.7k, False: 0]
  |  Branch (48:25): [True: 14.0k, False: 72.7k]
  ------------------
   49|  86.7k|         }
   50|  86.7k|      }
_ZN3tao5pegtl8internal3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSC_4RuleEEEEbRT3_DpOT4_:
   41|  1.16M|      {
   42|  1.16M|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  1.16M|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  1.16M|         }
   45|  1.16M|         else {
   46|  1.16M|            auto m = in.template mark< M >();
   47|  1.16M|            using m_t = decltype( m );
   48|  2.31M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.15M, False: 14.0k]
  |  Branch (48:25): [True: 1.15M, False: 0]
  ------------------
   49|  1.16M|         }
   50|  1.16M|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6targetENS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS4_9device_idEEEENS6_IJSA_NS0_4listINS4_15rule_attributesESA_vEEEEENS6_IJNS4_7commentEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNST_11char_traitsIcEENST_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  47.7k|      {
   42|  47.7k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  47.7k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  47.7k|         }
   45|  47.7k|         else {
   46|  47.7k|            auto m = in.template mark< M >();
   47|  47.7k|            using m_t = decltype( m );
   48|   260k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 38.9k, False: 4.45k]
  |  Branch (48:25): [True: 38.9k, False: 0]
  |  Branch (48:25): [True: 43.4k, False: 8]
  |  Branch (48:25): [True: 43.4k, False: 4.31k]
  ------------------
   49|  47.7k|         }
   50|  47.7k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  43.4k|      {
   42|  43.4k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  43.4k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  43.4k|         }
   45|  43.4k|         else {
   46|  43.4k|            auto m = in.template mark< M >();
   47|  43.4k|            using m_t = decltype( m );
   48|  84.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 40.5k, False: 2.90k]
  |  Branch (48:25): [True: 2.79k, False: 37.7k]
  ------------------
   49|  43.4k|         }
   50|  43.4k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10device_vidENS0_5ascii3oneIJLc58EEEENS4_10device_pidEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  40.5k|      {
   42|  40.5k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  40.5k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  40.5k|         }
   45|  40.5k|         else {
   46|  40.5k|            auto m = in.template mark< M >();
   47|  40.5k|            using m_t = decltype( m );
   48|  49.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.81k, False: 24]
  |  Branch (48:25): [True: 2.80k, False: 9]
  |  Branch (48:25): [True: 2.83k, False: 37.7k]
  ------------------
   49|  40.5k|         }
   50|  40.5k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   41|  43.4k|      {
   42|  43.4k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  43.4k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  43.4k|         }
   45|  43.4k|         else {
   46|  43.4k|            auto m = in.template mark< M >();
   47|  43.4k|            using m_t = decltype( m );
   48|  82.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 38.5k, False: 4.85k]
  |  Branch (48:25): [True: 28.5k, False: 10.0k]
  ------------------
   49|  43.4k|         }
   50|  43.4k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15rule_attributesENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  38.5k|      {
   42|  38.5k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  38.5k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  38.5k|         }
   45|  38.5k|         else {
   46|  38.5k|            auto m = in.template mark< M >();
   47|  38.5k|            using m_t = decltype( m );
   48|  67.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 28.7k, False: 9.83k]
  |  Branch (48:25): [True: 28.5k, False: 214]
  ------------------
   49|  38.5k|         }
   50|  38.5k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6str_idENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_15device_id_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  44.1k|      {
   42|  44.1k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  44.1k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  44.1k|         }
   45|  44.1k|         else {
   46|  44.1k|            auto m = in.template mark< M >();
   47|  44.1k|            using m_t = decltype( m );
   48|  52.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.81k, False: 21]
  |  Branch (48:25): [True: 2.38k, False: 434]
  |  Branch (48:25): [True: 2.83k, False: 41.2k]
  ------------------
   49|  44.1k|         }
   50|  44.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_15device_id_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  2.81k|      {
   42|  2.81k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.81k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.81k|         }
   45|  2.81k|         else {
   46|  2.81k|            auto m = in.template mark< M >();
   47|  2.81k|            using m_t = decltype( m );
   48|  24.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.21k, False: 0]
  |  Branch (48:25): [True: 2.03k, False: 178]
  |  Branch (48:25): [True: 2.21k, False: 59]
  |  Branch (48:25): [True: 2.27k, False: 0]
  |  Branch (48:25): [True: 2.27k, False: 544]
  |  Branch (48:25): [True: 2.81k, False: 0]
  ------------------
   49|  2.81k|         }
   50|  2.81k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.81k|      {
   42|  2.81k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.81k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.81k|         }
   45|  2.81k|         else {
   46|  2.81k|            auto m = in.template mark< M >();
   47|  2.81k|            using m_t = decltype( m );
   48|  4.03k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.22k, False: 1.59k]
  |  Branch (48:25): [True: 1.18k, False: 42]
  ------------------
   49|  2.81k|         }
   50|  2.81k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15device_id_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.27k|      {
   42|  2.27k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.27k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.27k|         }
   45|  2.27k|         else {
   46|  2.27k|            auto m = in.template mark< M >();
   47|  2.27k|            using m_t = decltype( m );
   48|  4.48k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.21k, False: 57]
  |  Branch (48:25): [True: 2.21k, False: 2]
  ------------------
   49|  2.27k|         }
   50|  2.27k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   724k|      {
   42|   724k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   724k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   724k|         }
   45|   724k|         else {
   46|   724k|            auto m = in.template mark< M >();
   47|   724k|            using m_t = decltype( m );
   48|  1.44M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 722k, False: 1.40k]
  |  Branch (48:25): [True: 721k, False: 811]
  ------------------
   49|   724k|         }
   50|   724k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10device_vidENS0_5ascii3oneIJLc58EEEENS4_10device_pidEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|   725k|      {
   42|   725k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   725k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   725k|         }
   45|   725k|         else {
   46|   725k|            auto m = in.template mark< M >();
   47|   725k|            using m_t = decltype( m );
   48|  2.89M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 724k, False: 34]
  |  Branch (48:25): [True: 724k, False: 30]
  |  Branch (48:25): [True: 724k, False: 1.23k]
  ------------------
   49|   725k|         }
   50|   725k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser8str_nameENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  41.7k|      {
   42|  41.7k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  41.7k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  41.7k|         }
   45|  41.7k|         else {
   46|  41.7k|            auto m = in.template mark< M >();
   47|  41.7k|            using m_t = decltype( m );
   48|  56.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.89k, False: 17]
  |  Branch (48:25): [True: 4.20k, False: 692]
  |  Branch (48:25): [True: 4.91k, False: 36.8k]
  ------------------
   49|  41.7k|         }
   50|  41.7k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.89k|      {
   42|  4.89k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.89k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.89k|         }
   45|  4.89k|         else {
   46|  4.89k|            auto m = in.template mark< M >();
   47|  4.89k|            using m_t = decltype( m );
   48|  37.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.26k, False: 0]
  |  Branch (48:25): [True: 3.13k, False: 128]
  |  Branch (48:25): [True: 3.26k, False: 65]
  |  Branch (48:25): [True: 3.32k, False: 0]
  |  Branch (48:25): [True: 3.32k, False: 1.56k]
  |  Branch (48:25): [True: 4.89k, False: 0]
  ------------------
   49|  4.89k|         }
   50|  4.89k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.89k|      {
   42|  4.89k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.89k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.89k|         }
   45|  4.89k|         else {
   46|  4.89k|            auto m = in.template mark< M >();
   47|  4.89k|            using m_t = decltype( m );
   48|  7.26k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.37k, False: 2.52k]
  |  Branch (48:25): [True: 2.32k, False: 43]
  ------------------
   49|  4.89k|         }
   50|  4.89k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.32k|      {
   42|  3.32k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.32k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.32k|         }
   45|  3.32k|         else {
   46|  3.32k|            auto m = in.template mark< M >();
   47|  3.32k|            using m_t = decltype( m );
   48|  6.60k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.27k, False: 54]
  |  Branch (48:25): [True: 3.26k, False: 11]
  ------------------
   49|  3.32k|         }
   50|  3.32k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   481k|      {
   42|   481k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   481k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   481k|         }
   45|   481k|         else {
   46|   481k|            auto m = in.template mark< M >();
   47|   481k|            using m_t = decltype( m );
   48|   960k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 479k, False: 2.23k]
  |  Branch (48:25): [True: 478k, False: 1.03k]
  ------------------
   49|   481k|         }
   50|   481k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser8str_hashENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  37.1k|      {
   42|  37.1k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  37.1k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  37.1k|         }
   45|  37.1k|         else {
   46|  37.1k|            auto m = in.template mark< M >();
   47|  37.1k|            using m_t = decltype( m );
   48|  50.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.53k, False: 16]
  |  Branch (48:25): [True: 3.83k, False: 697]
  |  Branch (48:25): [True: 4.55k, False: 32.6k]
  ------------------
   49|  37.1k|         }
   50|  37.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.53k|      {
   42|  4.53k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.53k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.53k|         }
   45|  4.53k|         else {
   46|  4.53k|            auto m = in.template mark< M >();
   47|  4.53k|            using m_t = decltype( m );
   48|  37.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.35k, False: 0]
  |  Branch (48:25): [True: 3.21k, False: 139]
  |  Branch (48:25): [True: 3.35k, False: 54]
  |  Branch (48:25): [True: 3.41k, False: 0]
  |  Branch (48:25): [True: 3.41k, False: 1.12k]
  |  Branch (48:25): [True: 4.53k, False: 0]
  ------------------
   49|  4.53k|         }
   50|  4.53k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.53k|      {
   42|  4.53k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.53k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.53k|         }
   45|  4.53k|         else {
   46|  4.53k|            auto m = in.template mark< M >();
   47|  4.53k|            using m_t = decltype( m );
   48|  6.61k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.07k, False: 2.45k]
  |  Branch (48:25): [True: 2.03k, False: 37]
  ------------------
   49|  4.53k|         }
   50|  4.53k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.41k|      {
   42|  3.41k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.41k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.41k|         }
   45|  3.41k|         else {
   46|  3.41k|            auto m = in.template mark< M >();
   47|  3.41k|            using m_t = decltype( m );
   48|  6.77k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.36k, False: 50]
  |  Branch (48:25): [True: 3.35k, False: 4]
  ------------------
   49|  3.41k|         }
   50|  3.41k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  8.99k|      {
   42|  8.99k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  8.99k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  8.99k|         }
   45|  8.99k|         else {
   46|  8.99k|            auto m = in.template mark< M >();
   47|  8.99k|            using m_t = decltype( m );
   48|  15.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 6.40k, False: 2.58k]
  |  Branch (48:25): [True: 5.63k, False: 771]
  ------------------
   49|  8.99k|         }
   50|  8.99k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15str_parent_hashENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  32.9k|      {
   42|  32.9k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  32.9k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  32.9k|         }
   45|  32.9k|         else {
   46|  32.9k|            auto m = in.template mark< M >();
   47|  32.9k|            using m_t = decltype( m );
   48|  42.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.04k, False: 13]
  |  Branch (48:25): [True: 2.49k, False: 549]
  |  Branch (48:25): [True: 3.05k, False: 29.8k]
  ------------------
   49|  32.9k|         }
   50|  32.9k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.04k|      {
   42|  3.04k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.04k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.04k|         }
   45|  3.04k|         else {
   46|  3.04k|            auto m = in.template mark< M >();
   47|  3.04k|            using m_t = decltype( m );
   48|  24.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.18k, False: 0]
  |  Branch (48:25): [True: 2.07k, False: 104]
  |  Branch (48:25): [True: 2.18k, False: 70]
  |  Branch (48:25): [True: 2.25k, False: 0]
  |  Branch (48:25): [True: 2.25k, False: 792]
  |  Branch (48:25): [True: 3.04k, False: 0]
  ------------------
   49|  3.04k|         }
   50|  3.04k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.04k|      {
   42|  3.04k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.04k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.04k|         }
   45|  3.04k|         else {
   46|  3.04k|            auto m = in.template mark< M >();
   47|  3.04k|            using m_t = decltype( m );
   48|  4.48k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.44k, False: 1.59k]
  |  Branch (48:25): [True: 1.40k, False: 37]
  ------------------
   49|  3.04k|         }
   50|  3.04k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.25k|      {
   42|  2.25k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.25k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.25k|         }
   45|  2.25k|         else {
   46|  2.25k|            auto m = in.template mark< M >();
   47|  2.25k|            using m_t = decltype( m );
   48|  4.44k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.19k, False: 57]
  |  Branch (48:25): [True: 2.18k, False: 13]
  ------------------
   49|  2.25k|         }
   50|  2.25k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.94k|      {
   42|  4.94k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.94k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.94k|         }
   45|  4.94k|         else {
   46|  4.94k|            auto m = in.template mark< M >();
   47|  4.94k|            using m_t = decltype( m );
   48|  8.09k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.15k, False: 1.78k]
  |  Branch (48:25): [True: 2.74k, False: 410]
  ------------------
   49|  4.94k|         }
   50|  4.94k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10str_serialENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  30.1k|      {
   42|  30.1k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  30.1k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  30.1k|         }
   45|  30.1k|         else {
   46|  30.1k|            auto m = in.template mark< M >();
   47|  30.1k|            using m_t = decltype( m );
   48|  39.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.01k, False: 17]
  |  Branch (48:25): [True: 2.39k, False: 626]
  |  Branch (48:25): [True: 3.03k, False: 27.1k]
  ------------------
   49|  30.1k|         }
   50|  30.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.01k|      {
   42|  3.01k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.01k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.01k|         }
   45|  3.01k|         else {
   46|  3.01k|            auto m = in.template mark< M >();
   47|  3.01k|            using m_t = decltype( m );
   48|  20.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.66k, False: 0]
  |  Branch (48:25): [True: 1.55k, False: 111]
  |  Branch (48:25): [True: 1.66k, False: 63]
  |  Branch (48:25): [True: 1.72k, False: 0]
  |  Branch (48:25): [True: 1.72k, False: 1.29k]
  |  Branch (48:25): [True: 3.01k, False: 0]
  ------------------
   49|  3.01k|         }
   50|  3.01k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.01k|      {
   42|  3.01k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.01k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.01k|         }
   45|  3.01k|         else {
   46|  3.01k|            auto m = in.template mark< M >();
   47|  3.01k|            using m_t = decltype( m );
   48|  4.02k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.00k, False: 2.01k]
  |  Branch (48:25): [True: 973, False: 34]
  ------------------
   49|  3.01k|         }
   50|  3.01k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  1.72k|      {
   42|  1.72k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  1.72k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  1.72k|         }
   45|  1.72k|         else {
   46|  1.72k|            auto m = in.template mark< M >();
   47|  1.72k|            using m_t = decltype( m );
   48|  3.40k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.67k, False: 49]
  |  Branch (48:25): [True: 1.66k, False: 14]
  ------------------
   49|  1.72k|         }
   50|  1.72k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  3.45k|      {
   42|  3.45k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.45k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.45k|         }
   45|  3.45k|         else {
   46|  3.45k|            auto m = in.template mark< M >();
   47|  3.45k|            using m_t = decltype( m );
   48|  5.88k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.42k, False: 1.02k]
  |  Branch (48:25): [True: 1.77k, False: 650]
  ------------------
   49|  3.45k|         }
   50|  3.45k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12str_via_portENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  27.4k|      {
   42|  27.4k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  27.4k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  27.4k|         }
   45|  27.4k|         else {
   46|  27.4k|            auto m = in.template mark< M >();
   47|  27.4k|            using m_t = decltype( m );
   48|  36.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.15k, False: 5]
  |  Branch (48:25): [True: 2.49k, False: 658]
  |  Branch (48:25): [True: 3.16k, False: 24.2k]
  ------------------
   49|  27.4k|         }
   50|  27.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.15k|      {
   42|  3.15k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.15k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.15k|         }
   45|  3.15k|         else {
   46|  3.15k|            auto m = in.template mark< M >();
   47|  3.15k|            using m_t = decltype( m );
   48|  23.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.98k, False: 0]
  |  Branch (48:25): [True: 1.87k, False: 107]
  |  Branch (48:25): [True: 1.98k, False: 64]
  |  Branch (48:25): [True: 2.04k, False: 0]
  |  Branch (48:25): [True: 2.04k, False: 1.11k]
  |  Branch (48:25): [True: 3.15k, False: 0]
  ------------------
   49|  3.15k|         }
   50|  3.15k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.15k|      {
   42|  3.15k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.15k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.15k|         }
   45|  3.15k|         else {
   46|  3.15k|            auto m = in.template mark< M >();
   47|  3.15k|            using m_t = decltype( m );
   48|  4.52k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.36k, False: 1.79k]
  |  Branch (48:25): [True: 1.32k, False: 40]
  ------------------
   49|  3.15k|         }
   50|  3.15k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.04k|      {
   42|  2.04k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.04k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.04k|         }
   45|  2.04k|         else {
   46|  2.04k|            auto m = in.template mark< M >();
   47|  2.04k|            using m_t = decltype( m );
   48|  4.03k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.98k, False: 55]
  |  Branch (48:25): [True: 1.98k, False: 9]
  ------------------
   49|  2.04k|         }
   50|  2.04k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  3.76k|      {
   42|  3.76k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.76k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.76k|         }
   45|  3.76k|         else {
   46|  3.76k|            auto m = in.template mark< M >();
   47|  3.76k|            using m_t = decltype( m );
   48|  6.18k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.41k, False: 1.34k]
  |  Branch (48:25): [True: 1.77k, False: 641]
  ------------------
   49|  3.76k|         }
   50|  3.76k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser18str_with_interfaceENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_15interface_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  24.5k|      {
   42|  24.5k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  24.5k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  24.5k|         }
   45|  24.5k|         else {
   46|  24.5k|            auto m = in.template mark< M >();
   47|  24.5k|            using m_t = decltype( m );
   48|  35.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.58k, False: 16]
  |  Branch (48:25): [True: 3.16k, False: 418]
  |  Branch (48:25): [True: 3.60k, False: 20.9k]
  ------------------
   49|  24.5k|         }
   50|  24.5k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_15interface_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.58k|      {
   42|  3.58k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.58k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.58k|         }
   45|  3.58k|         else {
   46|  3.58k|            auto m = in.template mark< M >();
   47|  3.58k|            using m_t = decltype( m );
   48|  28.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.56k, False: 0]
  |  Branch (48:25): [True: 2.40k, False: 163]
  |  Branch (48:25): [True: 2.56k, False: 61]
  |  Branch (48:25): [True: 2.62k, False: 0]
  |  Branch (48:25): [True: 2.62k, False: 963]
  |  Branch (48:25): [True: 3.58k, False: 0]
  ------------------
   49|  3.58k|         }
   50|  3.58k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.58k|      {
   42|  3.58k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.58k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.58k|         }
   45|  3.58k|         else {
   46|  3.58k|            auto m = in.template mark< M >();
   47|  3.58k|            using m_t = decltype( m );
   48|  5.45k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.86k, False: 1.72k]
  |  Branch (48:25): [True: 1.82k, False: 37]
  ------------------
   49|  3.58k|         }
   50|  3.58k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15interface_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.62k|      {
   42|  2.62k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.62k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.62k|         }
   45|  2.62k|         else {
   46|  2.62k|            auto m = in.template mark< M >();
   47|  2.62k|            using m_t = decltype( m );
   48|  5.18k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.56k, False: 60]
  |  Branch (48:25): [True: 2.56k, False: 1]
  ------------------
   49|  2.62k|         }
   50|  2.62k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   109k|      {
   42|   109k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   109k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   109k|         }
   45|   109k|         else {
   46|   109k|            auto m = in.template mark< M >();
   47|   109k|            using m_t = decltype( m );
   48|   217k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 108k, False: 1.58k]
  |  Branch (48:25): [True: 107k, False: 978]
  ------------------
   49|   109k|         }
   50|   109k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc58EEEENS4_14hex2orAsteriskES8_S9_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|   111k|      {
   42|   111k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   111k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   111k|         }
   45|   111k|         else {
   46|   111k|            auto m = in.template mark< M >();
   47|   111k|            using m_t = decltype( m );
   48|   885k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 110k, False: 29]
  |  Branch (48:25): [True: 110k, False: 16]
  |  Branch (48:25): [True: 110k, False: 35]
  |  Branch (48:25): [True: 110k, False: 41]
  |  Branch (48:25): [True: 110k, False: 1.33k]
  ------------------
   49|   111k|         }
   50|   111k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser21str_with_connect_typeENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  21.3k|      {
   42|  21.3k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  21.3k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  21.3k|         }
   45|  21.3k|         else {
   46|  21.3k|            auto m = in.template mark< M >();
   47|  21.3k|            using m_t = decltype( m );
   48|  31.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.50k, False: 13]
  |  Branch (48:25): [True: 2.90k, False: 604]
  |  Branch (48:25): [True: 3.51k, False: 17.8k]
  ------------------
   49|  21.3k|         }
   50|  21.3k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.50k|      {
   42|  3.50k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.50k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.50k|         }
   45|  3.50k|         else {
   46|  3.50k|            auto m = in.template mark< M >();
   47|  3.50k|            using m_t = decltype( m );
   48|  29.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.69k, False: 0]
  |  Branch (48:25): [True: 2.58k, False: 108]
  |  Branch (48:25): [True: 2.69k, False: 54]
  |  Branch (48:25): [True: 2.74k, False: 0]
  |  Branch (48:25): [True: 2.74k, False: 759]
  |  Branch (48:25): [True: 3.50k, False: 0]
  ------------------
   49|  3.50k|         }
   50|  3.50k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.50k|      {
   42|  3.50k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  3.50k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  3.50k|         }
   45|  3.50k|         else {
   46|  3.50k|            auto m = in.template mark< M >();
   47|  3.50k|            using m_t = decltype( m );
   48|  4.94k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.44k, False: 2.06k]
  |  Branch (48:25): [True: 1.41k, False: 34]
  ------------------
   49|  3.50k|         }
   50|  3.50k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.74k|      {
   42|  2.74k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.74k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.74k|         }
   45|  2.74k|         else {
   46|  2.74k|            auto m = in.template mark< M >();
   47|  2.74k|            using m_t = decltype( m );
   48|  5.44k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.70k, False: 44]
  |  Branch (48:25): [True: 2.69k, False: 10]
  ------------------
   49|  2.74k|         }
   50|  2.74k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.48k|      {
   42|  4.48k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.48k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.48k|         }
   45|  4.48k|         else {
   46|  4.48k|            auto m = in.template mark< M >();
   47|  4.48k|            using m_t = decltype( m );
   48|  7.36k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.87k, False: 1.60k]
  |  Branch (48:25): [True: 1.78k, False: 1.09k]
  ------------------
   49|  4.48k|         }
   50|  4.48k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6str_ifENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_9conditionEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  18.1k|      {
   42|  18.1k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  18.1k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  18.1k|         }
   45|  18.1k|         else {
   46|  18.1k|            auto m = in.template mark< M >();
   47|  18.1k|            using m_t = decltype( m );
   48|  38.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 6.76k, False: 22]
  |  Branch (48:25): [True: 4.19k, False: 2.57k]
  |  Branch (48:25): [True: 6.78k, False: 11.3k]
  ------------------
   49|  18.1k|         }
   50|  18.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_9conditionESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  6.76k|      {
   42|  6.76k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  6.76k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  6.76k|         }
   45|  6.76k|         else {
   46|  6.76k|            auto m = in.template mark< M >();
   47|  6.76k|            using m_t = decltype( m );
   48|  47.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.25k, False: 0]
  |  Branch (48:25): [True: 2.75k, False: 507]
  |  Branch (48:25): [True: 3.25k, False: 1.20k]
  |  Branch (48:25): [True: 4.46k, False: 0]
  |  Branch (48:25): [True: 4.46k, False: 2.30k]
  |  Branch (48:25): [True: 6.76k, False: 0]
  ------------------
   49|  6.76k|         }
   50|  6.76k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  6.76k|      {
   42|  6.76k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  6.76k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  6.76k|         }
   45|  6.76k|         else {
   46|  6.76k|            auto m = in.template mark< M >();
   47|  6.76k|            using m_t = decltype( m );
   48|  8.63k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.86k, False: 4.89k]
  |  Branch (48:25): [True: 1.77k, False: 91]
  ------------------
   49|  6.76k|         }
   50|  6.76k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser9conditionENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.46k|      {
   42|  4.46k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.46k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.46k|         }
   45|  4.46k|         else {
   46|  4.46k|            auto m = in.template mark< M >();
   47|  4.46k|            using m_t = decltype( m );
   48|  8.78k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.32k, False: 138]
  |  Branch (48:25): [True: 3.25k, False: 1.06k]
  ------------------
   49|  4.46k|         }
   50|  4.46k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   286k|      {
   42|   286k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   286k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   286k|         }
   45|   286k|         else {
   46|   286k|            auto m = in.template mark< M >();
   47|   286k|            using m_t = decltype( m );
   48|   571k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 284k, False: 2.35k]
  |  Branch (48:25): [True: 282k, False: 1.97k]
  ------------------
   49|   286k|         }
   50|   286k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser8negationEEEENS5_20condition_identifierENS3_IJNS5_18condition_argumentEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|   291k|      {
   42|   291k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   291k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   291k|         }
   45|   291k|         else {
   46|   291k|            auto m = in.template mark< M >();
   47|   291k|            using m_t = decltype( m );
   48|  1.16M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 290k, False: 1.56k]
  |  Branch (48:25): [True: 289k, False: 366]
  |  Branch (48:25): [True: 291k, False: 0]
  ------------------
   49|   291k|         }
   50|   291k|      }
_ZN3tao5pegtl8internal3seqIJNS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEENS0_4starINS4_IJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   41|   291k|      {
   42|   291k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|   291k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|   291k|         }
   45|   291k|         else {
   46|   291k|            auto m = in.template mark< M >();
   47|   291k|            using m_t = decltype( m );
   48|   582k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 290k, False: 1.56k]
  |  Branch (48:25): [True: 290k, False: 0]
  ------------------
   49|   291k|         }
   50|   291k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser9str_labelENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  11.9k|      {
   42|  11.9k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  11.9k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  11.9k|         }
   45|  11.9k|         else {
   46|  11.9k|            auto m = in.template mark< M >();
   47|  11.9k|            using m_t = decltype( m );
   48|  25.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.34k, False: 19]
  |  Branch (48:25): [True: 3.67k, False: 666]
  |  Branch (48:25): [True: 4.36k, False: 7.60k]
  ------------------
   49|  11.9k|         }
   50|  11.9k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.34k|      {
   42|  4.34k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.34k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.34k|         }
   45|  4.34k|         else {
   46|  4.34k|            auto m = in.template mark< M >();
   47|  4.34k|            using m_t = decltype( m );
   48|  28.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.24k, False: 0]
  |  Branch (48:25): [True: 2.13k, False: 112]
  |  Branch (48:25): [True: 2.24k, False: 64]
  |  Branch (48:25): [True: 2.30k, False: 0]
  |  Branch (48:25): [True: 2.30k, False: 2.03k]
  |  Branch (48:25): [True: 4.34k, False: 0]
  ------------------
   49|  4.34k|         }
   50|  4.34k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.34k|      {
   42|  4.34k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.34k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.34k|         }
   45|  4.34k|         else {
   46|  4.34k|            auto m = in.template mark< M >();
   47|  4.34k|            using m_t = decltype( m );
   48|  5.97k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.63k, False: 2.71k]
  |  Branch (48:25): [True: 1.57k, False: 54]
  ------------------
   49|  4.34k|         }
   50|  4.34k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.30k|      {
   42|  2.30k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  2.30k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  2.30k|         }
   45|  2.30k|         else {
   46|  2.30k|            auto m = in.template mark< M >();
   47|  2.30k|            using m_t = decltype( m );
   48|  4.56k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.25k, False: 49]
  |  Branch (48:25): [True: 2.24k, False: 15]
  ------------------
   49|  2.30k|         }
   50|  2.30k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.59k|      {
   42|  4.59k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  4.59k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  4.59k|         }
   45|  4.59k|         else {
   46|  4.59k|            auto m = in.template mark< M >();
   47|  4.59k|            using m_t = decltype( m );
   48|  7.66k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.06k, False: 1.52k]
  |  Branch (48:25): [True: 2.34k, False: 728]
  ------------------
   49|  4.59k|         }
   50|  4.59k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS8_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  31.7k|      {
   42|  31.7k|         if constexpr( sizeof...( Rules ) == 1 ) {
  ------------------
  |  Branch (42:24): [Folded - Ignored]
  ------------------
   43|  31.7k|            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|  31.7k|         }
   45|  31.7k|         else {
   46|  31.7k|            auto m = in.template mark< M >();
   47|  31.7k|            using m_t = decltype( m );
   48|  37.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 5.54k, False: 26.2k]
  |  Branch (48:25): [True: 2.99k, False: 2.55k]
  ------------------
   49|  31.7k|         }
   50|  31.7k|      }

_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  47.7k|      {
   58|  47.7k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  47.7k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSI_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  47.7k|      {
   45|  95.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 29, False: 47.7k]
  |  Branch (45:19): [True: 43.4k, False: 4.31k]
  ------------------
   46|  47.7k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  47.7k|      {
   58|  47.7k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  47.7k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  47.7k|      {
   45|   106k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.66k, False: 4.82k]
  |  Branch (45:19): [True: 508, False: 4.31k]
  |  Branch (45:19): [True: 264, False: 7.48k]
  |  Branch (45:19): [True: 3.99k, False: 7.75k]
  |  Branch (45:19): [True: 36.0k, False: 11.7k]
  ------------------
   46|  47.7k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  43.3k|      {
   58|  43.3k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  43.3k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  43.3k|      {
   45|  84.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.13k, False: 41.2k]
  |  Branch (45:19): [True: 3.50k, False: 37.7k]
  ------------------
   46|  43.3k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser12id_attributeENS4_14name_attributeENS4_14hash_attributeENS4_21parent_hash_attributeENS4_16serial_attributeENS4_18via_port_attributeENS4_24with_interface_attributeENS4_27with_connect_type_attributeENS4_19condition_attributeENS4_15label_attributeEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  44.1k|      {
   58|  44.1k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  44.1k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser12id_attributeENS4_14name_attributeENS4_14hash_attributeENS4_21parent_hash_attributeENS4_16serial_attributeENS4_18via_port_attributeENS4_24with_interface_attributeENS4_27with_connect_type_attributeENS4_19condition_attributeENS4_15label_attributeEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSQ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  44.1k|      {
   45|   522k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 6.14k, False: 11.9k]
  |  Branch (45:19): [True: 4.03k, False: 7.93k]
  |  Branch (45:19): [True: 3.25k, False: 18.1k]
  |  Branch (45:19): [True: 3.17k, False: 21.3k]
  |  Branch (45:19): [True: 2.86k, False: 24.5k]
  |  Branch (45:19): [True: 2.74k, False: 27.4k]
  |  Branch (45:19): [True: 2.79k, False: 30.1k]
  |  Branch (45:19): [True: 4.21k, False: 32.9k]
  |  Branch (45:19): [True: 4.58k, False: 37.1k]
  |  Branch (45:19): [True: 2.38k, False: 41.7k]
  ------------------
   46|  44.1k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.81k|      {
   58|  2.81k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.81k|      {
   45|  3.59k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.03k, False: 778]
  |  Branch (45:19): [True: 348, False: 430]
  ------------------
   46|  2.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.81k|      {
   58|  2.81k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.81k|      {
   45|  23.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 224, False: 1.78k]
  |  Branch (45:19): [True: 196, False: 1.59k]
  |  Branch (45:19): [True: 194, False: 2.01k]
  |  Branch (45:19): [True: 197, False: 2.20k]
  |  Branch (45:19): [True: 204, False: 2.40k]
  |  Branch (45:19): [True: 208, False: 2.60k]
  ------------------
   46|  2.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  1.45M|      {
   58|  1.45M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  1.45M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  1.45M|      {
   45|  2.89M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.52k, False: 1.44M]
  |  Branch (45:19): [True: 1.44M, False: 1.26k]
  ------------------
   46|  1.45M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.89k|      {
   58|  4.89k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.89k|      {
   45|  6.63k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.15k, False: 1.73k]
  |  Branch (45:19): [True: 1.42k, False: 314]
  ------------------
   46|  4.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.89k|      {
   58|  4.89k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.89k|      {
   45|  37.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 450, False: 2.72k]
  |  Branch (45:19): [True: 196, False: 2.52k]
  |  Branch (45:19): [True: 551, False: 3.17k]
  |  Branch (45:19): [True: 201, False: 3.72k]
  |  Branch (45:19): [True: 252, False: 3.92k]
  |  Branch (45:19): [True: 721, False: 4.17k]
  ------------------
   46|  4.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  9.12M|      {
   58|  9.12M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.12M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  9.12M|      {
   45|  18.0M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 165k, False: 8.95M]
  |  Branch (45:19): [True: 8.95M, False: 191]
  ------------------
   46|  9.12M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   165k|      {
   58|   165k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   165k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   165k|      {
   45|   537k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 66.7k, False: 751]
  |  Branch (45:19): [True: 683, False: 68]
  |  Branch (45:19): [True: 50.4k, False: 67.5k]
  |  Branch (45:19): [True: 47.9k, False: 117k]
  ------------------
   46|   165k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.53k|      {
   58|  4.53k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.53k|      {
   45|  5.83k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.23k, False: 1.29k]
  |  Branch (45:19): [True: 974, False: 323]
  ------------------
   46|  4.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.53k|      {
   58|  4.53k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.53k|      {
   45|  36.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 488, False: 2.67k]
  |  Branch (45:19): [True: 220, False: 2.45k]
  |  Branch (45:19): [True: 207, False: 3.16k]
  |  Branch (45:19): [True: 559, False: 3.37k]
  |  Branch (45:19): [True: 231, False: 3.93k]
  |  Branch (45:19): [True: 371, False: 4.16k]
  ------------------
   46|  4.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  9.70M|      {
   58|  9.70M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.70M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  9.70M|      {
   45|  19.2M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 107k, False: 9.59M]
  |  Branch (45:19): [True: 9.59M, False: 196]
  ------------------
   46|  9.70M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   107k|      {
   58|   107k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   107k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   107k|      {
   45|   333k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 43.7k, False: 1.03k]
  |  Branch (45:19): [True: 969, False: 61]
  |  Branch (45:19): [True: 23.2k, False: 44.7k]
  |  Branch (45:19): [True: 39.3k, False: 67.9k]
  ------------------
   46|   107k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.04k|      {
   58|  3.04k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.04k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.04k|      {
   45|  3.96k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.11k, False: 924]
  |  Branch (45:19): [True: 669, False: 255]
  ------------------
   46|  3.04k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.04k|      {
   58|  3.04k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.04k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.04k|      {
   45|  23.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 251, False: 1.79k]
  |  Branch (45:19): [True: 194, False: 1.59k]
  |  Branch (45:19): [True: 70, False: 2.04k]
  |  Branch (45:19): [True: 457, False: 2.11k]
  |  Branch (45:19): [True: 210, False: 2.56k]
  |  Branch (45:19): [True: 264, False: 2.77k]
  ------------------
   46|  3.04k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.29M|      {
   58|  6.29M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.29M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.29M|      {
   45|  12.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 97.4k, False: 6.20M]
  |  Branch (45:19): [True: 6.20M, False: 175]
  ------------------
   46|  6.29M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  97.4k|      {
   58|  97.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  97.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  97.4k|      {
   45|   283k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 35.5k, False: 926]
  |  Branch (45:19): [True: 889, False: 37]
  |  Branch (45:19): [True: 19.5k, False: 36.4k]
  |  Branch (45:19): [True: 41.5k, False: 55.9k]
  ------------------
   46|  97.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.01k|      {
   58|  3.01k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.01k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.01k|      {
   45|  4.45k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.58k, False: 1.43k]
  |  Branch (45:19): [True: 1.16k, False: 275]
  ------------------
   46|  3.01k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.01k|      {
   58|  3.01k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.01k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.01k|      {
   45|  25.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 128, False: 2.04k]
  |  Branch (45:19): [True: 34, False: 2.01k]
  |  Branch (45:19): [True: 278, False: 2.17k]
  |  Branch (45:19): [True: 202, False: 2.45k]
  |  Branch (45:19): [True: 286, False: 2.65k]
  |  Branch (45:19): [True: 79, False: 2.94k]
  ------------------
   46|  3.01k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  7.34M|      {
   58|  7.34M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.34M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  7.34M|      {
   45|  14.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 151k, False: 7.19M]
  |  Branch (45:19): [True: 7.19M, False: 193]
  ------------------
   46|  7.34M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   151k|      {
   58|   151k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   151k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   151k|      {
   45|   520k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 68.8k, False: 1.99k]
  |  Branch (45:19): [True: 1.94k, False: 52]
  |  Branch (45:19): [True: 42.2k, False: 70.8k]
  |  Branch (45:19): [True: 37.9k, False: 113k]
  ------------------
   46|   151k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.15k|      {
   58|  3.15k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.15k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.15k|      {
   45|  4.41k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.90k, False: 1.25k]
  |  Branch (45:19): [True: 960, False: 294]
  ------------------
   46|  3.15k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.15k|      {
   58|  3.15k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.15k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.15k|      {
   45|  26.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 338, False: 1.99k]
  |  Branch (45:19): [True: 201, False: 1.79k]
  |  Branch (45:19): [True: 195, False: 2.33k]
  |  Branch (45:19): [True: 211, False: 2.52k]
  |  Branch (45:19): [True: 220, False: 2.73k]
  |  Branch (45:19): [True: 201, False: 2.95k]
  ------------------
   46|  3.15k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  7.87M|      {
   58|  7.87M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.87M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  7.87M|      {
   45|  15.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 156k, False: 7.71M]
  |  Branch (45:19): [True: 7.71M, False: 197]
  ------------------
   46|  7.87M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   156k|      {
   58|   156k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   156k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   156k|      {
   45|   576k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 79.1k, False: 1.70k]
  |  Branch (45:19): [True: 1.65k, False: 52]
  |  Branch (45:19): [True: 47.2k, False: 80.8k]
  |  Branch (45:19): [True: 28.6k, False: 128k]
  ------------------
   46|   156k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.58k|      {
   58|  3.58k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.58k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.58k|      {
   45|  4.77k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.40k, False: 1.18k]
  |  Branch (45:19): [True: 770, False: 415]
  ------------------
   46|  3.58k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.58k|      {
   58|  3.58k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.58k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.58k|      {
   45|  30.1k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 510, False: 2.05k]
  |  Branch (45:19): [True: 326, False: 1.72k]
  |  Branch (45:19): [True: 374, False: 2.56k]
  |  Branch (45:19): [True: 304, False: 2.93k]
  |  Branch (45:19): [True: 275, False: 3.23k]
  |  Branch (45:19): [True: 74, False: 3.51k]
  ------------------
   46|  3.58k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   221k|      {
   58|   221k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   221k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   221k|      {
   45|   413k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 28.4k, False: 192k]
  |  Branch (45:19): [True: 192k, False: 51]
  ------------------
   46|   221k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.50k|      {
   58|  3.50k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.50k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.50k|      {
   45|  4.40k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.60k, False: 901]
  |  Branch (45:19): [True: 648, False: 253]
  ------------------
   46|  3.50k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.50k|      {
   58|  3.50k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.50k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.50k|      {
   45|  27.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 131, False: 2.26k]
  |  Branch (45:19): [True: 200, False: 2.06k]
  |  Branch (45:19): [True: 194, False: 2.39k]
  |  Branch (45:19): [True: 330, False: 2.58k]
  |  Branch (45:19): [True: 231, False: 2.91k]
  |  Branch (45:19): [True: 358, False: 3.14k]
  ------------------
   46|  3.50k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  5.66M|      {
   58|  5.66M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.66M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  5.66M|      {
   45|  11.2M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 116k, False: 5.54M]
  |  Branch (45:19): [True: 5.54M, False: 191]
  ------------------
   46|  5.66M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   116k|      {
   58|   116k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   116k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   116k|      {
   45|   394k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 50.9k, False: 1.25k]
  |  Branch (45:19): [True: 1.19k, False: 53]
  |  Branch (45:19): [True: 33.7k, False: 52.1k]
  |  Branch (45:19): [True: 30.9k, False: 85.8k]
  ------------------
   46|   116k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.76k|      {
   58|  6.76k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.76k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.76k|      {
   45|  9.61k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.91k, False: 2.84k]
  |  Branch (45:19): [True: 2.22k, False: 621]
  ------------------
   46|  6.76k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.76k|      {
   58|  6.76k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.76k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.76k|      {
   45|  59.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 512, False: 5.08k]
  |  Branch (45:19): [True: 194, False: 4.89k]
  |  Branch (45:19): [True: 226, False: 5.60k]
  |  Branch (45:19): [True: 200, False: 5.82k]
  |  Branch (45:19): [True: 404, False: 6.02k]
  |  Branch (45:19): [True: 332, False: 6.43k]
  ------------------
   46|  6.76k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc41EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  23.8M|      {
   58|  23.8M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  23.8M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc41EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  23.8M|      {
   45|  47.6M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 155k, False: 23.7M]
  |  Branch (45:19): [True: 23.7M, False: 272]
  ------------------
   46|  23.8M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   155k|      {
   58|   155k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   155k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   155k|      {
   45|   565k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 79.5k, False: 389]
  |  Branch (45:19): [True: 337, False: 52]
  |  Branch (45:19): [True: 45.0k, False: 79.9k]
  |  Branch (45:19): [True: 30.6k, False: 124k]
  ------------------
   46|   155k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.34k|      {
   58|  4.34k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.34k|      {
   45|  6.53k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.15k, False: 2.18k]
  |  Branch (45:19): [True: 1.88k, False: 306]
  ------------------
   46|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.34k|      {
   58|  4.34k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.34k|      {
   45|  37.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 444, False: 2.94k]
  |  Branch (45:19): [True: 230, False: 2.71k]
  |  Branch (45:19): [True: 272, False: 3.38k]
  |  Branch (45:19): [True: 226, False: 3.65k]
  |  Branch (45:19): [True: 249, False: 3.88k]
  |  Branch (45:19): [True: 211, False: 4.13k]
  ------------------
   46|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  7.34M|      {
   58|  7.34M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.34M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  7.34M|      {
   45|  14.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 121k, False: 7.22M]
  |  Branch (45:19): [True: 7.22M, False: 195]
  ------------------
   46|  7.34M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   121k|      {
   58|   121k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   121k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   121k|      {
   45|   419k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 55.5k, False: 1.80k]
  |  Branch (45:19): [True: 1.73k, False: 62]
  |  Branch (45:19): [True: 33.3k, False: 57.3k]
  |  Branch (45:19): [True: 30.3k, False: 90.7k]
  ------------------
   46|   121k|      }

_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  86.7k|      {
   41|   100k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 14.1k, False: 86.7k]
  ------------------
   42|  14.1k|         }
   43|  86.7k|         return true;
   44|  86.7k|      }
_ZN3tao5pegtl8internal4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEbRT3_DpOT4_:
   40|  14.0k|      {
   41|  1.16M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.15M, False: 14.0k]
  ------------------
   42|  1.15M|         }
   43|  14.0k|         return true;
   44|  14.0k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.48k|      {
   41|  7.51k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.03k, False: 4.48k]
  ------------------
   42|  3.03k|         }
   43|  4.48k|         return true;
   44|  4.48k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.21k|      {
   41|   724k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 721k, False: 2.21k]
  ------------------
   42|   721k|         }
   43|  2.21k|         return true;
   44|  2.21k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.59k|      {
   41|  11.2k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 4.68k, False: 6.59k]
  ------------------
   42|  4.68k|         }
   43|  6.59k|         return true;
   44|  6.59k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  3.27k|      {
   41|   481k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 478k, False: 3.27k]
  ------------------
   42|   478k|         }
   43|  3.27k|         return true;
   44|  3.27k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.76k|      {
   41|  8.96k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.19k, False: 6.76k]
  ------------------
   42|  2.19k|         }
   43|  6.76k|         return true;
   44|  6.76k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  3.36k|      {
   41|  8.99k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 5.63k, False: 3.36k]
  ------------------
   42|  5.63k|         }
   43|  3.36k|         return true;
   44|  3.36k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.43k|      {
   41|  7.16k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.72k, False: 4.43k]
  ------------------
   42|  2.72k|         }
   43|  4.43k|         return true;
   44|  4.43k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.19k|      {
   41|  4.94k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.74k, False: 2.19k]
  ------------------
   42|  2.74k|         }
   43|  2.19k|         return true;
   44|  2.19k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.39k|      {
   41|  5.10k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.71k, False: 3.39k]
  ------------------
   42|  1.71k|         }
   43|  3.39k|         return true;
   44|  3.39k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  1.67k|      {
   41|  3.45k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.77k, False: 1.67k]
  ------------------
   42|  1.77k|         }
   43|  1.67k|         return true;
   44|  1.67k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.02k|      {
   41|  6.07k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.05k, False: 4.02k]
  ------------------
   42|  2.05k|         }
   43|  4.02k|         return true;
   44|  4.02k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  1.98k|      {
   41|  3.76k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.77k, False: 1.98k]
  ------------------
   42|  1.77k|         }
   43|  1.98k|         return true;
   44|  1.98k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.18k|      {
   41|  8.22k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.03k, False: 5.18k]
  ------------------
   42|  3.03k|         }
   43|  5.18k|         return true;
   44|  5.18k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.56k|      {
   41|   109k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 107k, False: 2.56k]
  ------------------
   42|   107k|         }
   43|  2.56k|         return true;
   44|  2.56k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.43k|      {
   41|  8.62k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.18k, False: 5.43k]
  ------------------
   42|  3.18k|         }
   43|  5.43k|         return true;
   44|  5.43k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.70k|      {
   41|  4.48k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.78k, False: 2.70k]
  ------------------
   42|  1.78k|         }
   43|  2.70k|         return true;
   44|  2.70k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  7.71k|      {
   41|  10.5k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.86k, False: 7.71k]
  ------------------
   42|  2.86k|         }
   43|  7.71k|         return true;
   44|  7.71k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  4.32k|      {
   41|   286k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 282k, False: 4.32k]
  ------------------
   42|   282k|         }
   43|  4.32k|         return true;
   44|  4.32k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   40|   290k|      {
   41|  12.6M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 12.3M, False: 290k]
  ------------------
   42|  12.3M|         }
   43|   290k|         return true;
   44|   290k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.54k|      {
   41|  10.3k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 5.77k, False: 4.54k]
  ------------------
   42|  5.77k|         }
   43|  4.54k|         return true;
   44|  4.54k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.25k|      {
   41|  4.59k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.34k, False: 2.25k]
  ------------------
   42|  2.34k|         }
   43|  2.25k|         return true;
   44|  2.25k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  28.7k|      {
   41|  31.7k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.99k, False: 28.7k]
  ------------------
   42|  2.99k|         }
   43|  28.7k|         return true;
   44|  28.7k|      }

_ZN3tao5pegtl8internal13unsafe_equalsEPKcRKSt16initializer_listIcE:
   23|   477k|   {
   24|   477k|      return std::memcmp( s, &*l.begin(), l.size() ) == 0;
   25|   477k|   }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc111ELc119EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  47.7k|      {
   52|  47.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 47.3k, False: 404]
  ------------------
   53|  47.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 36.0k, False: 11.3k]
  ------------------
   54|  36.0k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  36.0k|               return true;
   56|  36.0k|            }
   57|  47.3k|         }
   58|  11.7k|         return false;
   59|  47.7k|      }
_ZN3tao5pegtl8internal6stringIJLc98ELc108ELc111ELc99ELc107EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  11.7k|      {
   52|  11.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 11.3k, False: 404]
  ------------------
   53|  11.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.99k, False: 7.34k]
  ------------------
   54|  3.99k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.99k|               return true;
   56|  3.99k|            }
   57|  11.3k|         }
   58|  7.75k|         return false;
   59|  11.7k|      }
_ZN3tao5pegtl8internal6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  7.75k|      {
   52|  7.75k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 6.83k, False: 922]
  ------------------
   53|  6.83k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 264, False: 6.56k]
  ------------------
   54|    264|               bump_help< string >( in, sizeof...( Cs ) );
   55|    264|               return true;
   56|    264|            }
   57|  6.83k|         }
   58|  7.48k|         return false;
   59|  7.75k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  7.48k|      {
   52|  7.48k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 7.08k, False: 404]
  ------------------
   53|  7.08k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.66k, False: 4.42k]
  ------------------
   54|  2.66k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.66k|               return true;
   56|  2.66k|            }
   57|  7.08k|         }
   58|  4.82k|         return false;
   59|  7.48k|      }
_ZN3tao5pegtl8internal6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  4.82k|      {
   52|  4.82k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 4.26k, False: 565]
  ------------------
   53|  4.26k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 508, False: 3.75k]
  ------------------
   54|    508|               bump_help< string >( in, sizeof...( Cs ) );
   55|    508|               return true;
   56|    508|            }
   57|  4.26k|         }
   58|  4.31k|         return false;
   59|  4.82k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  44.1k|      {
   52|  44.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 42.7k, False: 1.33k]
  ------------------
   53|  42.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.83k, False: 39.9k]
  ------------------
   54|  2.83k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.83k|               return true;
   56|  2.83k|            }
   57|  42.7k|         }
   58|  41.2k|         return false;
   59|  44.1k|      }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  39.6k|      {
   52|  39.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 32.5k, False: 7.08k]
  ------------------
   53|  32.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.81k, False: 29.7k]
  ------------------
   54|  2.81k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.81k|               return true;
   56|  2.81k|            }
   57|  32.5k|         }
   58|  36.8k|         return false;
   59|  39.6k|      }
_ZN3tao5pegtl8internal6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  36.8k|      {
   52|  36.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 29.7k, False: 7.08k]
  ------------------
   53|  29.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.56k, False: 27.1k]
  ------------------
   54|  2.56k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.56k|               return true;
   56|  2.56k|            }
   57|  29.7k|         }
   58|  34.2k|         return false;
   59|  36.8k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  34.2k|      {
   52|  34.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 25.8k, False: 8.41k]
  ------------------
   53|  25.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.88k, False: 22.9k]
  ------------------
   54|  2.88k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.88k|               return true;
   56|  2.88k|            }
   57|  25.8k|         }
   58|  31.3k|         return false;
   59|  34.2k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  31.3k|      {
   52|  31.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.9k, False: 14.4k]
  ------------------
   53|  16.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.56k, False: 14.3k]
  ------------------
   54|  2.56k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.56k|               return true;
   56|  2.56k|            }
   57|  16.9k|         }
   58|  28.8k|         return false;
   59|  31.3k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  28.8k|      {
   52|  28.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 21.7k, False: 7.08k]
  ------------------
   53|  21.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.47k, False: 18.2k]
  ------------------
   54|  3.47k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.47k|               return true;
   56|  3.47k|            }
   57|  21.7k|         }
   58|  25.3k|         return false;
   59|  28.8k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  25.3k|      {
   52|  25.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 15.9k, False: 9.40k]
  ------------------
   53|  15.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 1.99k, False: 13.9k]
  ------------------
   54|  1.99k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  1.99k|               return true;
   56|  1.99k|            }
   57|  15.9k|         }
   58|  23.3k|         return false;
   59|  25.3k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc97ELc109ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  41.7k|      {
   52|  41.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 39.8k, False: 1.94k]
  ------------------
   53|  39.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.91k, False: 34.8k]
  ------------------
   54|  4.91k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.91k|               return true;
   56|  4.91k|            }
   57|  39.8k|         }
   58|  36.8k|         return false;
   59|  41.7k|      }
_ZN3tao5pegtl8internal6stringIJLc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  37.1k|      {
   52|  37.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 35.2k, False: 1.94k]
  ------------------
   53|  35.2k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.55k, False: 30.6k]
  ------------------
   54|  4.55k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.55k|               return true;
   56|  4.55k|            }
   57|  35.2k|         }
   58|  32.6k|         return false;
   59|  37.1k|      }
_ZN3tao5pegtl8internal6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  32.9k|      {
   52|  32.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 27.6k, False: 5.33k]
  ------------------
   53|  27.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.05k, False: 24.5k]
  ------------------
   54|  3.05k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.05k|               return true;
   56|  3.05k|            }
   57|  27.6k|         }
   58|  29.8k|         return false;
   59|  32.9k|      }
_ZN3tao5pegtl8internal6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  30.1k|      {
   52|  30.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 27.6k, False: 2.47k]
  ------------------
   53|  27.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.03k, False: 24.6k]
  ------------------
   54|  3.03k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.03k|               return true;
   56|  3.03k|            }
   57|  27.6k|         }
   58|  27.1k|         return false;
   59|  30.1k|      }
_ZN3tao5pegtl8internal6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  27.4k|      {
   52|  27.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 24.1k, False: 3.29k]
  ------------------
   53|  24.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.16k, False: 20.9k]
  ------------------
   54|  3.16k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.16k|               return true;
   56|  3.16k|            }
   57|  24.1k|         }
   58|  24.2k|         return false;
   59|  27.4k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  24.5k|      {
   52|  24.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 18.7k, False: 5.77k]
  ------------------
   53|  18.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.60k, False: 15.1k]
  ------------------
   54|  3.60k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.60k|               return true;
   56|  3.60k|            }
   57|  18.7k|         }
   58|  20.9k|         return false;
   59|  24.5k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  21.3k|      {
   52|  21.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 14.8k, False: 6.49k]
  ------------------
   53|  14.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.52k, False: 11.3k]
  ------------------
   54|  3.52k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.52k|               return true;
   56|  3.52k|            }
   57|  14.8k|         }
   58|  17.8k|         return false;
   59|  21.3k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  18.1k|      {
   52|  18.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.7k, False: 1.33k]
  ------------------
   53|  16.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 6.79k, False: 9.99k]
  ------------------
   54|  6.79k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  6.79k|               return true;
   56|  6.79k|            }
   57|  16.7k|         }
   58|  11.3k|         return false;
   59|  18.1k|      }
_ZN3tao5pegtl8internal6stringIJLc108ELc97ELc98ELc101ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  11.9k|      {
   52|  11.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 9.76k, False: 2.20k]
  ------------------
   53|  9.76k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.36k, False: 5.39k]
  ------------------
   54|  4.36k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.36k|               return true;
   56|  4.36k|            }
   57|  9.76k|         }
   58|  7.60k|         return false;
   59|  11.9k|      }

_ZN3tao5pegtl8internal5untilINS0_3eofEJNS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS7_4ruleEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS7_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  38.3k|      {
   71|  38.3k|         auto m = in.template mark< M >();
   72|  38.3k|         using m_t = decltype( m );
   73|       |
   74|  86.1k|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 47.7k, False: 38.3k]
  ------------------
   75|  47.7k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 0, False: 47.7k]
  ------------------
   76|      0|               return false;
   77|      0|            }
   78|  47.7k|         }
   79|  38.3k|         return m( true );
   80|  38.3k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|   482k|      {
   71|   482k|         auto m = in.template mark< M >();
   72|   482k|         using m_t = decltype( m );
   73|       |
   74|  9.60M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.12M, False: 482k]
  ------------------
   75|  9.12M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 191, False: 9.12M]
  ------------------
   76|    191|               return false;
   77|    191|            }
   78|  9.12M|         }
   79|   482k|         return m( true );
   80|   482k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  9.98k|      {
   71|  9.98k|         auto m = in.template mark< M >();
   72|  9.98k|         using m_t = decltype( m );
   73|       |
   74|  9.71M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.70M, False: 9.79k]
  ------------------
   75|  9.70M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 196, False: 9.70M]
  ------------------
   76|    196|               return false;
   77|    196|            }
   78|  9.70M|         }
   79|  9.79k|         return m( true );
   80|  9.98k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.65k|      {
   71|  5.65k|         auto m = in.template mark< M >();
   72|  5.65k|         using m_t = decltype( m );
   73|       |
   74|  6.30M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 6.29M, False: 5.47k]
  ------------------
   75|  6.29M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 175, False: 6.29M]
  ------------------
   76|    175|               return false;
   77|    175|            }
   78|  6.29M|         }
   79|  5.47k|         return m( true );
   80|  5.65k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  4.64k|      {
   71|  4.64k|         auto m = in.template mark< M >();
   72|  4.64k|         using m_t = decltype( m );
   73|       |
   74|  7.35M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.34M, False: 4.45k]
  ------------------
   75|  7.34M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 193, False: 7.34M]
  ------------------
   76|    193|               return false;
   77|    193|            }
   78|  7.34M|         }
   79|  4.45k|         return m( true );
   80|  4.64k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  4.75k|      {
   71|  4.75k|         auto m = in.template mark< M >();
   72|  4.75k|         using m_t = decltype( m );
   73|       |
   74|  7.87M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.87M, False: 4.56k]
  ------------------
   75|  7.87M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 197, False: 7.87M]
  ------------------
   76|    197|               return false;
   77|    197|            }
   78|  7.87M|         }
   79|  4.56k|         return m( true );
   80|  4.75k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.15k|      {
   71|  5.15k|         auto m = in.template mark< M >();
   72|  5.15k|         using m_t = decltype( m );
   73|       |
   74|  5.66M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 5.66M, False: 4.96k]
  ------------------
   75|  5.66M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 191, False: 5.66M]
  ------------------
   76|    191|               return false;
   77|    191|            }
   78|  5.66M|         }
   79|  4.96k|         return m( true );
   80|  5.15k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  35.6k|      {
   71|  35.6k|         auto m = in.template mark< M >();
   72|  35.6k|         using m_t = decltype( m );
   73|       |
   74|  23.9M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 23.8M, False: 35.4k]
  ------------------
   75|  23.8M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 272, False: 23.8M]
  ------------------
   76|    272|               return false;
   77|    272|            }
   78|  23.8M|         }
   79|  35.4k|         return m( true );
   80|  35.6k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.50k|      {
   71|  6.50k|         auto m = in.template mark< M >();
   72|  6.50k|         using m_t = decltype( m );
   73|       |
   74|  7.35M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.34M, False: 6.31k]
  ------------------
   75|  7.34M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 195, False: 7.34M]
  ------------------
   76|    195|               return false;
   77|    195|            }
   78|  7.34M|         }
   79|  6.31k|         return m( true );
   80|  6.50k|      }

_ZN3tao5pegtl5matchIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.3k|   {
  104|  38.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  38.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  38.3k|      }
  107|  38.3k|      else {
  108|  38.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  38.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  38.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  38.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  38.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  38.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  38.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  38.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  38.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  38.3k|         }
  128|       |
  129|  38.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  38.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  38.3k|         }
  132|       |
  133|  38.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  38.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.5k, False: 8.77k]
  ------------------
  143|  29.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  29.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  29.5k|            }
  146|  29.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  29.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  29.5k|            }
  149|  29.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  29.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  29.5k|            }
  152|  29.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  29.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.5k|            }
  155|  29.5k|         }
  156|  38.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.5k, False: 8.77k]
  ------------------
  157|  29.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.5k|         }
  159|  8.77k|         else {
  160|  8.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.77k|         }
  162|  38.3k|         (void)m( result );
  163|  38.3k|         return result;
  164|  38.3k|      }
  165|  38.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.3k|      {
   73|  38.3k|#if defined( __cpp_exceptions )
   74|  38.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  38.3k|            try {
   76|  38.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  38.3k|            }
   78|  38.3k|            catch( ... ) {
   79|  38.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  38.3k|               throw;
   81|  38.3k|            }
   82|  38.3k|         }
   83|  38.3k|         else {
   84|  38.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.3k|      {
   44|  38.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.3k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  77.3k|   {
  104|  77.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  77.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  77.3k|      }
  107|  77.3k|      else {
  108|  77.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  77.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  77.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  77.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  77.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  77.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  77.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  77.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  77.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  77.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  77.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  77.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  77.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  77.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  77.3k|         }
  128|       |
  129|  77.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  77.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  77.3k|         }
  132|       |
  133|  77.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  77.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  77.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  77.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  77.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  77.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  77.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  77.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.5k, False: 47.7k]
  ------------------
  143|  29.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  29.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  29.5k|            }
  146|  29.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  29.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  29.5k|            }
  149|  29.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  29.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  29.5k|            }
  152|  29.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  29.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.5k|            }
  155|  29.5k|         }
  156|  77.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.5k, False: 47.7k]
  ------------------
  157|  29.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.5k|         }
  159|  47.7k|         else {
  160|  47.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.7k|         }
  162|  77.3k|         (void)m( result );
  163|  77.3k|         return result;
  164|  77.3k|      }
  165|  77.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
   72|  77.3k|      {
   73|  77.3k|#if defined( __cpp_exceptions )
   74|  77.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  77.3k|            try {
   76|  77.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  77.3k|            }
   78|  77.3k|            catch( ... ) {
   79|  77.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  77.3k|               throw;
   81|  77.3k|            }
   82|  77.3k|         }
   83|  77.3k|         else {
   84|  77.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  77.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  77.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  77.3k|      {
   59|  77.3k|         return Rule::match( in );
   60|  77.3k|      }
_ZN3tao5pegtl5matchINS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  47.7k|   {
  104|  47.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.7k|      }
  107|  47.7k|      else {
  108|  47.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.7k|         }
  128|       |
  129|  47.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.7k|         }
  132|       |
  133|  47.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.0k, False: 8.77k]
  ------------------
  143|  39.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  39.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  39.0k|            }
  146|  39.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  39.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  39.0k|            }
  149|  39.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  39.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  39.0k|            }
  152|  39.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  39.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.0k|            }
  155|  39.0k|         }
  156|  47.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.0k, False: 8.77k]
  ------------------
  157|  39.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.0k|         }
  159|  8.77k|         else {
  160|  8.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.77k|         }
  162|  47.7k|         (void)m( result );
  163|  47.7k|         return result;
  164|  47.7k|      }
  165|  47.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS6_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS6_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
   72|  47.7k|      {
   73|  47.7k|#if defined( __cpp_exceptions )
   74|  47.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.7k|            try {
   76|  47.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.7k|            }
   78|  47.7k|            catch( ... ) {
   79|  47.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.7k|               throw;
   81|  47.7k|            }
   82|  47.7k|         }
   83|  47.7k|         else {
   84|  47.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS6_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS6_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.7k|      {
   44|  47.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.7k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  47.7k|   {
  104|  47.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.7k|      }
  107|  47.7k|      else {
  108|  47.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.7k|         }
  128|       |
  129|  47.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.7k|         }
  132|       |
  133|  47.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.0k, False: 8.77k]
  ------------------
  143|  39.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  39.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  39.0k|            }
  146|  39.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  39.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  39.0k|            }
  149|  39.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  39.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  39.0k|            }
  152|  39.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  39.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.0k|            }
  155|  39.0k|         }
  156|  47.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.0k, False: 8.77k]
  ------------------
  157|  39.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.0k|         }
  159|  8.77k|         else {
  160|  8.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.77k|         }
  162|  47.7k|         (void)m( result );
  163|  47.7k|         return result;
  164|  47.7k|      }
  165|  47.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  47.7k|      {
   73|  47.7k|#if defined( __cpp_exceptions )
   74|  47.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.7k|            try {
   76|  47.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.7k|            }
   78|  47.7k|            catch( ... ) {
   79|  47.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.7k|               throw;
   81|  47.7k|            }
   82|  47.7k|         }
   83|  47.7k|         else {
   84|  47.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.7k|      {
   44|  47.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  86.7k|   {
  104|  86.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  86.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  86.7k|      }
  107|  86.7k|      else {
  108|  86.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  86.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  86.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  86.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  86.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  86.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  86.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  86.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  86.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  86.7k|         }
  128|       |
  129|  86.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  86.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  86.7k|         }
  132|       |
  133|  86.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  86.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  86.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.0k, False: 72.7k]
  ------------------
  143|  14.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  14.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  14.0k|            }
  146|  14.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  14.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  14.0k|            }
  149|  14.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  14.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  14.0k|            }
  152|  14.0k|            else if constexpr( has_apply0_bool ) {
  153|  14.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.0k|            }
  155|  14.0k|         }
  156|  86.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.0k, False: 72.7k]
  ------------------
  157|  14.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.0k|         }
  159|  72.7k|         else {
  160|  72.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  72.7k|         }
  162|  86.7k|         (void)m( result );
  163|  86.7k|         return result;
  164|  86.7k|      }
  165|  86.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  86.7k|      {
   73|  86.7k|#if defined( __cpp_exceptions )
   74|  86.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  86.7k|            try {
   76|  86.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  86.7k|            }
   78|  86.7k|            catch( ... ) {
   79|  86.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  86.7k|               throw;
   81|  86.7k|            }
   82|  86.7k|         }
   83|  86.7k|         else {
   84|  86.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  86.7k|      {
   44|  86.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  86.7k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  86.7k|   {
  104|  86.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  86.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  86.7k|      }
  107|  86.7k|      else {
  108|  86.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  86.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  86.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  86.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  86.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  86.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  86.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  86.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  86.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  86.7k|         }
  128|       |
  129|  86.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  86.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  86.7k|         }
  132|       |
  133|  86.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  86.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  86.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 86.7k, False: 0]
  ------------------
  143|  86.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  86.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  86.7k|            }
  146|  86.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  86.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  86.7k|            }
  149|  86.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  86.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  86.7k|            }
  152|  86.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  86.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  86.7k|            }
  155|  86.7k|         }
  156|  86.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 86.7k, False: 0]
  ------------------
  157|  86.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  86.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  86.7k|         (void)m( result );
  163|  86.7k|         return result;
  164|  86.7k|      }
  165|  86.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  86.7k|      {
   73|  86.7k|#if defined( __cpp_exceptions )
   74|  86.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  86.7k|            try {
   76|  86.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  86.7k|            }
   78|  86.7k|            catch( ... ) {
   79|  86.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  86.7k|               throw;
   81|  86.7k|            }
   82|  86.7k|         }
   83|  86.7k|         else {
   84|  86.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  86.7k|      {
   44|  86.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  86.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   188k|   {
  104|   188k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   188k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   188k|      }
  107|   188k|      else {
  108|   188k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   188k|         using iterator_t = typename ParseInput::iterator_t;
  111|   188k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   188k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   188k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   188k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   188k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   188k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   188k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   188k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   188k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   188k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   188k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   188k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   188k|         }
  128|       |
  129|   188k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   188k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   188k|         }
  132|       |
  133|   188k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   188k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   188k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   188k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   188k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   188k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   188k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   188k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.5k, False: 171k]
  ------------------
  143|  16.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  16.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  16.5k|            }
  146|  16.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  16.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  16.5k|            }
  149|  16.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  16.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  16.5k|            }
  152|  16.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  16.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.5k|            }
  155|  16.5k|         }
  156|   188k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.5k, False: 171k]
  ------------------
  157|  16.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.5k|         }
  159|   171k|         else {
  160|   171k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   171k|         }
  162|   188k|         (void)m( result );
  163|   188k|         return result;
  164|   188k|      }
  165|   188k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   188k|      {
   73|   188k|#if defined( __cpp_exceptions )
   74|   188k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   188k|            try {
   76|   188k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   188k|            }
   78|   188k|            catch( ... ) {
   79|   188k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   188k|               throw;
   81|   188k|            }
   82|   188k|         }
   83|   188k|         else {
   84|   188k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   188k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   188k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   188k|      {
   59|   188k|         return Rule::match( in );
   60|   188k|      }
_ZN3tao5pegtl5matchINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNSH_4RuleEEEEDaRT4_DpOT5_:
  103|  86.7k|   {
  104|  86.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  86.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  86.7k|      }
  107|  86.7k|      else {
  108|  86.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  86.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  86.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  86.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  86.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  86.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  86.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  86.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  86.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  86.7k|         }
  128|       |
  129|  86.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  86.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  86.7k|         }
  132|       |
  133|  86.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  86.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  86.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.0k, False: 72.7k]
  ------------------
  143|  14.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  14.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  14.0k|            }
  146|  14.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  14.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  14.0k|            }
  149|  14.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  14.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  14.0k|            }
  152|  14.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  14.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.0k|            }
  155|  14.0k|         }
  156|  86.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.0k, False: 72.7k]
  ------------------
  157|  14.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.0k|         }
  159|  72.7k|         else {
  160|  72.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  72.7k|         }
  162|  86.7k|         (void)m( result );
  163|  86.7k|         return result;
  164|  86.7k|      }
  165|  86.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS4_3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSI_4RuleEEEEDaRT4_DpOT5_:
   72|  86.7k|      {
   73|  86.7k|#if defined( __cpp_exceptions )
   74|  86.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  86.7k|            try {
   76|  86.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  86.7k|            }
   78|  86.7k|            catch( ... ) {
   79|  86.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  86.7k|               throw;
   81|  86.7k|            }
   82|  86.7k|         }
   83|  86.7k|         else {
   84|  86.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS4_3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSI_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  86.7k|      {
   44|  86.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  86.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  86.7k|   {
  104|  86.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  86.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  86.7k|      }
  107|  86.7k|      else {
  108|  86.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  86.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  86.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  86.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  86.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  86.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  86.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  86.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  86.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  86.7k|         }
  128|       |
  129|  86.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  86.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  86.7k|         }
  132|       |
  133|  86.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  86.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  86.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.0k, False: 72.7k]
  ------------------
  143|  14.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  14.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  14.0k|            }
  146|  14.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  14.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  14.0k|            }
  149|  14.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  14.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  14.0k|            }
  152|  14.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  14.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.0k|            }
  155|  14.0k|         }
  156|  86.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.0k, False: 72.7k]
  ------------------
  157|  14.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.0k|         }
  159|  72.7k|         else {
  160|  72.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  72.7k|         }
  162|  86.7k|         (void)m( result );
  163|  86.7k|         return result;
  164|  86.7k|      }
  165|  86.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  86.7k|      {
   73|  86.7k|#if defined( __cpp_exceptions )
   74|  86.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  86.7k|            try {
   76|  86.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  86.7k|            }
   78|  86.7k|            catch( ... ) {
   79|  86.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  86.7k|               throw;
   81|  86.7k|            }
   82|  86.7k|         }
   83|  86.7k|         else {
   84|  86.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  86.7k|      {
   59|  86.7k|         return Rule::match( in );
   60|  86.7k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDaRT4_DpOT5_:
  103|  14.0k|   {
  104|  14.0k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  14.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  14.0k|      }
  107|  14.0k|      else {
  108|  14.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  14.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  14.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  14.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  14.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  14.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  14.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  14.0k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  14.0k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  14.0k|         }
  128|       |
  129|  14.0k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  14.0k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  14.0k|         }
  132|       |
  133|  14.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  14.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  14.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.0k|         if( result ) {
  143|  14.0k|            if constexpr( has_apply_void ) {
  144|  14.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  14.0k|            }
  146|  14.0k|            else if constexpr( has_apply_bool ) {
  147|  14.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  14.0k|            }
  149|  14.0k|            else if constexpr( has_apply0_void ) {
  150|  14.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  14.0k|            }
  152|  14.0k|            else if constexpr( has_apply0_bool ) {
  153|  14.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.0k|            }
  155|  14.0k|         }
  156|  14.0k|         if( result ) {
  157|  14.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.0k|         }
  159|  14.0k|         else {
  160|  14.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.0k|         }
  162|  14.0k|         (void)m( result );
  163|  14.0k|         return result;
  164|  14.0k|      }
  165|  14.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  14.0k|      {
   44|  14.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.0k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEDaRT4_DpOT5_:
  103|  14.0k|   {
  104|  14.0k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  14.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  14.0k|      }
  107|  14.0k|      else {
  108|  14.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  14.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  14.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  14.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  14.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  14.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  14.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  14.0k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  14.0k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  14.0k|         }
  128|       |
  129|  14.0k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  14.0k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  14.0k|         }
  132|       |
  133|  14.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  14.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  14.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.0k, False: 0]
  ------------------
  143|  14.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  14.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  14.0k|            }
  146|  14.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  14.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  14.0k|            }
  149|  14.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  14.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  14.0k|            }
  152|  14.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  14.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.0k|            }
  155|  14.0k|         }
  156|  14.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.0k, False: 0]
  ------------------
  157|  14.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  14.0k|         (void)m( result );
  163|  14.0k|         return result;
  164|  14.0k|      }
  165|  14.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDaRT4_DpOT5_:
   72|  14.0k|      {
   73|  14.0k|#if defined( __cpp_exceptions )
   74|  14.0k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  14.0k|            try {
   76|  14.0k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  14.0k|            }
   78|  14.0k|            catch( ... ) {
   79|  14.0k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  14.0k|               throw;
   81|  14.0k|            }
   82|  14.0k|         }
   83|  14.0k|         else {
   84|  14.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  14.0k|      {
   44|  14.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.0k|      }
_ZN3tao5pegtl5matchINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  1.16M|   {
  104|  1.16M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.16M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.16M|      }
  107|  1.16M|      else {
  108|  1.16M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.16M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.16M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.16M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.16M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.16M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.16M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.16M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.16M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.16M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.16M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.16M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.16M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.16M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.16M|         }
  128|       |
  129|  1.16M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.16M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.16M|         }
  132|       |
  133|  1.16M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.16M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.16M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.16M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.16M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.16M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.16M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.16M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.15M, False: 14.0k]
  ------------------
  143|  1.15M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.15M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.15M|            }
  146|  1.15M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.15M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.15M|            }
  149|  1.15M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.15M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.15M|            }
  152|  1.15M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.15M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.15M|            }
  155|  1.15M|         }
  156|  1.16M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.15M, False: 14.0k]
  ------------------
  157|  1.15M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.15M|         }
  159|  14.0k|         else {
  160|  14.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.0k|         }
  162|  1.16M|         (void)m( result );
  163|  1.16M|         return result;
  164|  1.16M|      }
  165|  1.16M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSC_4RuleEEEEDaRT4_DpOT5_:
   72|  1.16M|      {
   73|  1.16M|#if defined( __cpp_exceptions )
   74|  1.16M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.16M|            try {
   76|  1.16M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.16M|            }
   78|  1.16M|            catch( ... ) {
   79|  1.16M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.16M|               throw;
   81|  1.16M|            }
   82|  1.16M|         }
   83|  1.16M|         else {
   84|  1.16M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.16M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.16M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSC_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.16M|      {
   44|  1.16M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.16M|      }
_ZN3tao5pegtl5matchINS0_6not_atIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.16M|   {
  104|  1.16M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.16M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.16M|      }
  107|  1.16M|      else {
  108|  1.16M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.16M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.16M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.16M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.16M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.16M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.16M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.16M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.16M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.16M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.16M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.16M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.16M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.16M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.16M|         }
  128|       |
  129|  1.16M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.16M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.16M|         }
  132|       |
  133|  1.16M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.16M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.16M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.16M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.16M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.16M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.16M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.16M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.15M, False: 14.0k]
  ------------------
  143|  1.15M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.15M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.15M|            }
  146|  1.15M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.15M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.15M|            }
  149|  1.15M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.15M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.15M|            }
  152|  1.15M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.15M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.15M|            }
  155|  1.15M|         }
  156|  1.16M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.15M, False: 14.0k]
  ------------------
  157|  1.15M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.15M|         }
  159|  14.0k|         else {
  160|  14.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.0k|         }
  162|  1.16M|         (void)m( result );
  163|  1.16M|         return result;
  164|  1.16M|      }
  165|  1.16M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_6not_atIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.16M|      {
   73|  1.16M|#if defined( __cpp_exceptions )
   74|  1.16M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.16M|            try {
   76|  1.16M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.16M|            }
   78|  1.16M|            catch( ... ) {
   79|  1.16M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.16M|               throw;
   81|  1.16M|            }
   82|  1.16M|         }
   83|  1.16M|         else {
   84|  1.16M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.16M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.16M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_6not_atIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.16M|      {
   44|  1.16M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.16M|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  1.16M|   {
  104|  1.16M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.16M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.16M|      }
  107|  1.16M|      else {
  108|  1.16M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.16M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.16M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.16M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.16M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.16M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.16M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.16M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.16M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.16M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.16M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.16M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.16M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.16M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.16M|         }
  128|       |
  129|  1.16M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.16M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.16M|         }
  132|       |
  133|  1.16M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.16M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.16M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.16M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.16M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.16M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.16M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.16M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.0k, False: 1.15M]
  ------------------
  143|  14.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  14.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  14.0k|            }
  146|  14.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  14.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  14.0k|            }
  149|  14.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  14.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  14.0k|            }
  152|  14.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  14.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.0k|            }
  155|  14.0k|         }
  156|  1.16M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.0k, False: 1.15M]
  ------------------
  157|  14.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.0k|         }
  159|  1.15M|         else {
  160|  1.15M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.15M|         }
  162|  1.16M|         (void)m( result );
  163|  1.16M|         return result;
  164|  1.16M|      }
  165|  1.16M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
   72|  1.16M|      {
   73|  1.16M|#if defined( __cpp_exceptions )
   74|  1.16M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.16M|            try {
   76|  1.16M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.16M|            }
   78|  1.16M|            catch( ... ) {
   79|  1.16M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.16M|               throw;
   81|  1.16M|            }
   82|  1.16M|         }
   83|  1.16M|         else {
   84|  1.16M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.16M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.16M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.16M|      {
   59|  1.16M|         return Rule::match( in );
   60|  1.16M|      }
_ZN3tao5pegtl5matchINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.15M|   {
  104|  1.15M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.15M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.15M|      }
  107|  1.15M|      else {
  108|  1.15M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.15M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.15M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.15M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.15M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.15M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.15M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.15M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.15M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.15M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.15M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.15M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.15M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.15M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.15M|         }
  128|       |
  129|  1.15M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.15M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.15M|         }
  132|       |
  133|  1.15M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.15M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.15M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.15M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.15M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.15M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.15M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.15M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.15M, False: 0]
  ------------------
  143|  1.15M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.15M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.15M|            }
  146|  1.15M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.15M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.15M|            }
  149|  1.15M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.15M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.15M|            }
  152|  1.15M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.15M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.15M|            }
  155|  1.15M|         }
  156|  1.15M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.15M, False: 0]
  ------------------
  157|  1.15M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.15M|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  1.15M|         (void)m( result );
  163|  1.15M|         return result;
  164|  1.15M|      }
  165|  1.15M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  1.15M|      {
   73|  1.15M|#if defined( __cpp_exceptions )
   74|  1.15M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.15M|            try {
   76|  1.15M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.15M|            }
   78|  1.15M|            catch( ... ) {
   79|  1.15M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.15M|               throw;
   81|  1.15M|            }
   82|  1.15M|         }
   83|  1.15M|         else {
   84|  1.15M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.15M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.15M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.15M|      {
   59|  1.15M|         return Rule::match( in );
   60|  1.15M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  47.7k|   {
  104|  47.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.7k|      }
  107|  47.7k|      else {
  108|  47.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.7k|         }
  128|       |
  129|  47.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.7k|         }
  132|       |
  133|  47.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.9k, False: 8.77k]
  ------------------
  143|  38.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  38.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  38.9k|            }
  146|  38.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  38.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  38.9k|            }
  149|  38.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  38.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  38.9k|            }
  152|  38.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  38.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.9k|            }
  155|  38.9k|         }
  156|  47.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.9k, False: 8.77k]
  ------------------
  157|  38.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.9k|         }
  159|  8.77k|         else {
  160|  8.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.77k|         }
  162|  47.7k|         (void)m( result );
  163|  47.7k|         return result;
  164|  47.7k|      }
  165|  47.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  47.7k|      {
   73|  47.7k|#if defined( __cpp_exceptions )
   74|  47.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.7k|            try {
   76|  47.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.7k|            }
   78|  47.7k|            catch( ... ) {
   79|  47.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.7k|               throw;
   81|  47.7k|            }
   82|  47.7k|         }
   83|  47.7k|         else {
   84|  47.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.7k|      {
   44|  47.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  47.7k|   {
  104|  47.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.7k|      }
  107|  47.7k|      else {
  108|  47.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.7k|         }
  128|       |
  129|  47.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.7k|         }
  132|       |
  133|  47.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.4k, False: 4.31k]
  ------------------
  143|  43.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  43.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  43.4k|            }
  146|  43.4k|            else if constexpr( has_apply_bool ) {
  147|  43.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  43.4k|            }
  149|  43.4k|            else if constexpr( has_apply0_void ) {
  150|  43.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  43.4k|            }
  152|  43.4k|            else if constexpr( has_apply0_bool ) {
  153|  43.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.4k|            }
  155|  43.4k|         }
  156|  47.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.4k, False: 4.31k]
  ------------------
  157|  43.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.4k|         }
  159|  4.31k|         else {
  160|  4.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.31k|         }
  162|  47.7k|         (void)m( result );
  163|  47.7k|         return result;
  164|  47.7k|      }
  165|  47.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  47.7k|      {
   73|  47.7k|#if defined( __cpp_exceptions )
   74|  47.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.7k|            try {
   76|  47.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.7k|            }
   78|  47.7k|            catch( ... ) {
   79|  47.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.7k|               throw;
   81|  47.7k|            }
   82|  47.7k|         }
   83|  47.7k|         else {
   84|  47.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.7k|      {
   44|  47.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  47.7k|   {
  104|  47.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.7k|      }
  107|  47.7k|      else {
  108|  47.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.7k|         }
  128|       |
  129|  47.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.7k|         }
  132|       |
  133|  47.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.0k, False: 11.7k]
  ------------------
  143|  36.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  36.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  36.0k|            }
  146|  36.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  36.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  36.0k|            }
  149|  36.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  36.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  36.0k|            }
  152|  36.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  36.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.0k|            }
  155|  36.0k|         }
  156|  47.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.0k, False: 11.7k]
  ------------------
  157|  36.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.0k|         }
  159|  11.7k|         else {
  160|  11.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.7k|         }
  162|  47.7k|         (void)m( result );
  163|  47.7k|         return result;
  164|  47.7k|      }
  165|  47.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  47.7k|      {
   73|  47.7k|#if defined( __cpp_exceptions )
   74|  47.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.7k|            try {
   76|  47.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.7k|            }
   78|  47.7k|            catch( ... ) {
   79|  47.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.7k|               throw;
   81|  47.7k|            }
   82|  47.7k|         }
   83|  47.7k|         else {
   84|  47.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  47.7k|      {
   59|  47.7k|         return Rule::match( in );
   60|  47.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.7k|   {
  104|  11.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  11.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  11.7k|      }
  107|  11.7k|      else {
  108|  11.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  11.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  11.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  11.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  11.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  11.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  11.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  11.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  11.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  11.7k|         }
  128|       |
  129|  11.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  11.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  11.7k|         }
  132|       |
  133|  11.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  11.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.99k, False: 7.75k]
  ------------------
  143|  3.99k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.99k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.99k|            }
  146|  3.99k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.99k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.99k|            }
  149|  3.99k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.99k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.99k|            }
  152|  3.99k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.99k|            }
  155|  3.99k|         }
  156|  11.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.99k, False: 7.75k]
  ------------------
  157|  3.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.99k|         }
  159|  7.75k|         else {
  160|  7.75k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.75k|         }
  162|  11.7k|         (void)m( result );
  163|  11.7k|         return result;
  164|  11.7k|      }
  165|  11.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.7k|      {
   73|  11.7k|#if defined( __cpp_exceptions )
   74|  11.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  11.7k|            try {
   76|  11.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  11.7k|            }
   78|  11.7k|            catch( ... ) {
   79|  11.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  11.7k|               throw;
   81|  11.7k|            }
   82|  11.7k|         }
   83|  11.7k|         else {
   84|  11.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  11.7k|      {
   59|  11.7k|         return Rule::match( in );
   60|  11.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.75k|   {
  104|  7.75k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.75k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.75k|      }
  107|  7.75k|      else {
  108|  7.75k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.75k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.75k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.75k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.75k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.75k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.75k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.75k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.75k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.75k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.75k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.75k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.75k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.75k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.75k|         }
  128|       |
  129|  7.75k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.75k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.75k|         }
  132|       |
  133|  7.75k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.75k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.75k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.75k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.75k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.75k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.75k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.75k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 264, False: 7.48k]
  ------------------
  143|    264|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    264|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    264|            }
  146|    264|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    264|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    264|            }
  149|    264|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    264|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    264|            }
  152|    264|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    264|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    264|            }
  155|    264|         }
  156|  7.75k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264, False: 7.48k]
  ------------------
  157|    264|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    264|         }
  159|  7.48k|         else {
  160|  7.48k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.48k|         }
  162|  7.75k|         (void)m( result );
  163|  7.75k|         return result;
  164|  7.75k|      }
  165|  7.75k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.75k|      {
   73|  7.75k|#if defined( __cpp_exceptions )
   74|  7.75k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.75k|            try {
   76|  7.75k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.75k|            }
   78|  7.75k|            catch( ... ) {
   79|  7.75k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.75k|               throw;
   81|  7.75k|            }
   82|  7.75k|         }
   83|  7.75k|         else {
   84|  7.75k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.75k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.75k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.75k|      {
   59|  7.75k|         return Rule::match( in );
   60|  7.75k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.48k|   {
  104|  7.48k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.48k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.48k|      }
  107|  7.48k|      else {
  108|  7.48k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.48k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.48k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.48k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.48k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.48k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.48k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.48k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.48k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.48k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.48k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.48k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.48k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.48k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.48k|         }
  128|       |
  129|  7.48k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.48k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.48k|         }
  132|       |
  133|  7.48k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.48k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.48k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.48k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.48k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.48k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.48k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.48k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.66k, False: 4.82k]
  ------------------
  143|  2.66k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.66k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.66k|            }
  146|  2.66k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.66k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.66k|            }
  149|  2.66k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.66k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.66k|            }
  152|  2.66k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.66k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.66k|            }
  155|  2.66k|         }
  156|  7.48k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.66k, False: 4.82k]
  ------------------
  157|  2.66k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.66k|         }
  159|  4.82k|         else {
  160|  4.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.82k|         }
  162|  7.48k|         (void)m( result );
  163|  7.48k|         return result;
  164|  7.48k|      }
  165|  7.48k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.48k|      {
   73|  7.48k|#if defined( __cpp_exceptions )
   74|  7.48k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.48k|            try {
   76|  7.48k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.48k|            }
   78|  7.48k|            catch( ... ) {
   79|  7.48k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.48k|               throw;
   81|  7.48k|            }
   82|  7.48k|         }
   83|  7.48k|         else {
   84|  7.48k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.48k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.48k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.48k|      {
   59|  7.48k|         return Rule::match( in );
   60|  7.48k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.82k|   {
  104|  4.82k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.82k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.82k|      }
  107|  4.82k|      else {
  108|  4.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.82k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.82k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.82k|         }
  128|       |
  129|  4.82k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.82k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.82k|         }
  132|       |
  133|  4.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.82k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 508, False: 4.31k]
  ------------------
  143|    508|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    508|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    508|            }
  146|    508|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    508|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    508|            }
  149|    508|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    508|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    508|            }
  152|    508|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    508|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    508|            }
  155|    508|         }
  156|  4.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 508, False: 4.31k]
  ------------------
  157|    508|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    508|         }
  159|  4.31k|         else {
  160|  4.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.31k|         }
  162|  4.82k|         (void)m( result );
  163|  4.82k|         return result;
  164|  4.82k|      }
  165|  4.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.82k|      {
   73|  4.82k|#if defined( __cpp_exceptions )
   74|  4.82k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.82k|            try {
   76|  4.82k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.82k|            }
   78|  4.82k|            catch( ... ) {
   79|  4.82k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.82k|               throw;
   81|  4.82k|            }
   82|  4.82k|         }
   83|  4.82k|         else {
   84|  4.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.82k|      {
   59|  4.82k|         return Rule::match( in );
   60|  4.82k|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  43.4k|   {
  104|  43.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  43.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  43.4k|      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  43.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  43.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  43.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  43.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  43.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  43.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  43.4k|         }
  128|       |
  129|  43.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  43.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  43.4k|         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.4k, False: 8]
  ------------------
  143|  43.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  43.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  43.4k|            }
  146|  43.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  43.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  43.4k|            }
  149|  43.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  43.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  43.4k|            }
  152|  43.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  43.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.4k|            }
  155|  43.4k|         }
  156|  43.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.4k, False: 8]
  ------------------
  157|  43.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.4k|         }
  159|      8|         else {
  160|      8|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      8|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  43.4k|      {
   73|  43.4k|#if defined( __cpp_exceptions )
   74|  43.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  43.4k|            try {
   76|  43.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  43.4k|            }
   78|  43.4k|            catch( ... ) {
   79|  43.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  43.4k|               throw;
   81|  43.4k|            }
   82|  43.4k|         }
   83|  43.4k|         else {
   84|  43.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  43.4k|      {
   44|  43.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.4k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  43.4k|   {
  104|  43.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  43.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  43.4k|      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  43.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  43.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  43.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  43.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  43.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  43.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  43.4k|         }
  128|       |
  129|  43.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  43.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  43.4k|         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  143|  43.4k|            if constexpr( has_apply_void ) {
  144|  43.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  43.4k|            }
  146|  43.4k|            else if constexpr( has_apply_bool ) {
  147|  43.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  43.4k|            }
  149|  43.4k|            else if constexpr( has_apply0_void ) {
  150|  43.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  43.4k|            }
  152|  43.4k|            else if constexpr( has_apply0_bool ) {
  153|  43.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.4k|            }
  155|  43.4k|         }
  156|  43.4k|         if( result ) {
  157|  43.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.4k|         }
  159|  43.4k|         else {
  160|  43.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.4k|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  43.4k|      {
   44|  43.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   118k|   {
  104|   118k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   118k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   118k|      }
  107|   118k|      else {
  108|   118k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   118k|         using iterator_t = typename ParseInput::iterator_t;
  111|   118k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   118k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   118k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   118k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   118k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   118k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   118k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   118k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   118k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   118k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   118k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   118k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   118k|         }
  128|       |
  129|   118k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   118k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   118k|         }
  132|       |
  133|   118k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   118k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   118k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   118k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   118k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   118k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   118k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   118k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 84.6k, False: 33.9k]
  ------------------
  143|  84.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  84.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  84.6k|            }
  146|  84.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  84.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  84.6k|            }
  149|  84.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  84.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  84.6k|            }
  152|  84.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  84.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  84.6k|            }
  155|  84.6k|         }
  156|   118k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 84.6k, False: 33.9k]
  ------------------
  157|  84.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  84.6k|         }
  159|  33.9k|         else {
  160|  33.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.9k|         }
  162|   118k|         (void)m( result );
  163|   118k|         return result;
  164|   118k|      }
  165|   118k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   118k|      {
   73|   118k|#if defined( __cpp_exceptions )
   74|   118k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   118k|            try {
   76|   118k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   118k|            }
   78|   118k|            catch( ... ) {
   79|   118k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   118k|               throw;
   81|   118k|            }
   82|   118k|         }
   83|   118k|         else {
   84|   118k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   118k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   118k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   118k|      {
   44|   118k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   118k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   118k|   {
  104|   118k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   118k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   118k|      }
  107|   118k|      else {
  108|   118k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   118k|         using iterator_t = typename ParseInput::iterator_t;
  111|   118k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   118k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   118k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   118k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   118k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   118k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   118k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   118k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   118k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   118k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   118k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   118k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   118k|         }
  128|       |
  129|   118k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   118k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   118k|         }
  132|       |
  133|   118k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   118k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   118k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   118k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   118k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   118k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   118k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   118k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 84.6k, False: 33.9k]
  ------------------
  143|  84.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  84.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  84.6k|            }
  146|  84.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  84.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  84.6k|            }
  149|  84.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  84.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  84.6k|            }
  152|  84.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  84.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  84.6k|            }
  155|  84.6k|         }
  156|   118k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 84.6k, False: 33.9k]
  ------------------
  157|  84.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  84.6k|         }
  159|  33.9k|         else {
  160|  33.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.9k|         }
  162|   118k|         (void)m( result );
  163|   118k|         return result;
  164|   118k|      }
  165|   118k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   118k|      {
   73|   118k|#if defined( __cpp_exceptions )
   74|   118k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   118k|            try {
   76|   118k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   118k|            }
   78|   118k|            catch( ... ) {
   79|   118k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   118k|               throw;
   81|   118k|            }
   82|   118k|         }
   83|   118k|         else {
   84|   118k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   118k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   118k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   118k|      {
   59|   118k|         return Rule::match( in );
   60|   118k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.5k|   {
  104|  40.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  40.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  40.5k|      }
  107|  40.5k|      else {
  108|  40.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  40.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  40.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  40.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  40.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  40.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  40.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  40.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  40.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  40.5k|         }
  128|       |
  129|  40.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  40.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  40.5k|         }
  132|       |
  133|  40.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  40.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  40.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.80k, False: 37.7k]
  ------------------
  143|  2.80k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.80k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.80k|            }
  146|  2.80k|            else if constexpr( has_apply_bool ) {
  147|  2.80k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.80k|            }
  149|  2.80k|            else if constexpr( has_apply0_void ) {
  150|  2.80k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.80k|            }
  152|  2.80k|            else if constexpr( has_apply0_bool ) {
  153|  2.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.80k|            }
  155|  2.80k|         }
  156|  40.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.79k, False: 37.7k]
  ------------------
  157|  2.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.79k|         }
  159|  37.7k|         else {
  160|  37.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.7k|         }
  162|  40.5k|         (void)m( result );
  163|  40.5k|         return result;
  164|  40.5k|      }
  165|  40.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  40.5k|      {
   73|  40.5k|#if defined( __cpp_exceptions )
   74|  40.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  40.5k|            try {
   76|  40.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  40.5k|            }
   78|  40.5k|            catch( ... ) {
   79|  40.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  40.5k|               throw;
   81|  40.5k|            }
   82|  40.5k|         }
   83|  40.5k|         else {
   84|  40.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  40.5k|      {
   44|  40.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.5k|   {
  104|  40.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  40.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  40.5k|      }
  107|  40.5k|      else {
  108|  40.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  40.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  40.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  40.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  40.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  40.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  40.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  40.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  40.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  40.5k|         }
  128|       |
  129|  40.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  40.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  40.5k|         }
  132|       |
  133|  40.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  40.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  40.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.83k, False: 37.7k]
  ------------------
  143|  2.83k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.83k|            }
  146|  2.83k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.83k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.83k|            }
  149|  2.83k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.83k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.83k|            }
  152|  2.83k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.83k|            }
  155|  2.83k|         }
  156|  40.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.83k, False: 37.7k]
  ------------------
  157|  2.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.83k|         }
  159|  37.7k|         else {
  160|  37.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.7k|         }
  162|  40.5k|         (void)m( result );
  163|  40.5k|         return result;
  164|  40.5k|      }
  165|  40.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  40.5k|      {
   73|  40.5k|#if defined( __cpp_exceptions )
   74|  40.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  40.5k|            try {
   76|  40.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  40.5k|            }
   78|  40.5k|            catch( ... ) {
   79|  40.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  40.5k|               throw;
   81|  40.5k|            }
   82|  40.5k|         }
   83|  40.5k|         else {
   84|  40.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  40.5k|      {
   44|  40.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.3k|   {
  104|  43.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  43.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  43.3k|      }
  107|  43.3k|      else {
  108|  43.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  43.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  43.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  43.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  43.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  43.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  43.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  43.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  43.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  43.3k|         }
  128|       |
  129|  43.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  43.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  43.3k|         }
  132|       |
  133|  43.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  43.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.13k, False: 41.2k]
  ------------------
  143|  2.13k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.13k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.13k|            }
  146|  2.13k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.13k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.13k|            }
  149|  2.13k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.13k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.13k|            }
  152|  2.13k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.13k|            }
  155|  2.13k|         }
  156|  43.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.13k, False: 41.2k]
  ------------------
  157|  2.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.13k|         }
  159|  41.2k|         else {
  160|  41.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.2k|         }
  162|  43.3k|         (void)m( result );
  163|  43.3k|         return result;
  164|  43.3k|      }
  165|  43.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  43.3k|      {
   73|  43.3k|#if defined( __cpp_exceptions )
   74|  43.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  43.3k|            try {
   76|  43.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  43.3k|            }
   78|  43.3k|            catch( ... ) {
   79|  43.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  43.3k|               throw;
   81|  43.3k|            }
   82|  43.3k|         }
   83|  43.3k|         else {
   84|  43.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  43.3k|      {
   44|  43.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  49.8k|   {
  104|  49.8k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  49.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  49.8k|      }
  107|  49.8k|      else {
  108|  49.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  49.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  49.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  49.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  49.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  49.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  49.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  49.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  49.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  49.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  49.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  49.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  49.8k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  49.8k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  49.8k|         }
  128|       |
  129|  49.8k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  49.8k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  49.8k|         }
  132|       |
  133|  49.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  49.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  49.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  49.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  49.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  49.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  49.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  49.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.57k, False: 41.2k]
  ------------------
  143|  8.57k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  8.57k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  8.57k|            }
  146|  8.57k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  8.57k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  8.57k|            }
  149|  8.57k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  8.57k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  8.57k|            }
  152|  8.57k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  8.57k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.57k|            }
  155|  8.57k|         }
  156|  49.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.57k, False: 41.2k]
  ------------------
  157|  8.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.57k|         }
  159|  41.2k|         else {
  160|  41.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.2k|         }
  162|  49.8k|         (void)m( result );
  163|  49.8k|         return result;
  164|  49.8k|      }
  165|  49.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  49.8k|      {
   73|  49.8k|#if defined( __cpp_exceptions )
   74|  49.8k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  49.8k|            try {
   76|  49.8k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  49.8k|            }
   78|  49.8k|            catch( ... ) {
   79|  49.8k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  49.8k|               throw;
   81|  49.8k|            }
   82|  49.8k|         }
   83|  49.8k|         else {
   84|  49.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  49.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  49.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  49.8k|      {
   59|  49.8k|         return Rule::match( in );
   60|  49.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  41.2k|   {
  104|  41.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  41.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  41.2k|      }
  107|  41.2k|      else {
  108|  41.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  41.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  41.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  41.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  41.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  41.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  41.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  41.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  41.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  41.2k|         }
  128|       |
  129|  41.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  41.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  41.2k|         }
  132|       |
  133|  41.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  41.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.50k, False: 37.7k]
  ------------------
  143|  3.50k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.50k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.50k|            }
  146|  3.50k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.50k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.50k|            }
  149|  3.50k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.50k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.50k|            }
  152|  3.50k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.50k|            }
  155|  3.50k|         }
  156|  41.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.50k, False: 37.7k]
  ------------------
  157|  3.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.50k|         }
  159|  37.7k|         else {
  160|  37.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.7k|         }
  162|  41.2k|         (void)m( result );
  163|  41.2k|         return result;
  164|  41.2k|      }
  165|  41.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  41.2k|      {
   73|  41.2k|#if defined( __cpp_exceptions )
   74|  41.2k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  41.2k|            try {
   76|  41.2k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  41.2k|            }
   78|  41.2k|            catch( ... ) {
   79|  41.2k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  41.2k|               throw;
   81|  41.2k|            }
   82|  41.2k|         }
   83|  41.2k|         else {
   84|  41.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  41.2k|      {
   59|  41.2k|         return Rule::match( in );
   60|  41.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.83k|   {
  104|  2.83k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.83k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.83k|      }
  107|  2.83k|      else {
  108|  2.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.83k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.83k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.83k|         }
  128|       |
  129|  2.83k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.83k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.83k|         }
  132|       |
  133|  2.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.81k, False: 24]
  ------------------
  143|  2.81k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.81k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.81k|            }
  146|  2.81k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.81k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.81k|            }
  149|  2.81k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.81k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.81k|            }
  152|  2.81k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.81k|            }
  155|  2.81k|         }
  156|  2.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.81k, False: 24]
  ------------------
  157|  2.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.81k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  2.83k|         (void)m( result );
  163|  2.83k|         return result;
  164|  2.83k|      }
  165|  2.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.83k|      {
   73|  2.83k|#if defined( __cpp_exceptions )
   74|  2.83k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.83k|            try {
   76|  2.83k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.83k|            }
   78|  2.83k|            catch( ... ) {
   79|  2.83k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.83k|               throw;
   81|  2.83k|            }
   82|  2.83k|         }
   83|  2.83k|         else {
   84|  2.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.83k|      {
   59|  2.83k|         return Rule::match( in );
   60|  2.83k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.80k, False: 9]
  ------------------
  143|  2.80k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.80k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.80k|            }
  146|  2.80k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.80k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.80k|            }
  149|  2.80k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.80k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.80k|            }
  152|  2.80k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.80k|            }
  155|  2.80k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.80k, False: 9]
  ------------------
  157|  2.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.80k|         }
  159|      9|         else {
  160|      9|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      9|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.81k|      {
   44|  2.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.81k|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  43.4k|   {
  104|  43.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  43.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  43.4k|      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  43.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  43.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  43.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  43.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  43.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  43.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  43.4k|         }
  128|       |
  129|  43.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  43.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  43.4k|         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.9k, False: 4.45k]
  ------------------
  143|  38.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  38.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  38.9k|            }
  146|  38.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  38.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  38.9k|            }
  149|  38.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  38.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  38.9k|            }
  152|  38.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  38.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.9k|            }
  155|  38.9k|         }
  156|  43.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.9k, False: 4.45k]
  ------------------
  157|  38.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.9k|         }
  159|  4.45k|         else {
  160|  4.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.45k|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENSA_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  43.4k|      {
   73|  43.4k|#if defined( __cpp_exceptions )
   74|  43.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  43.4k|            try {
   76|  43.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  43.4k|            }
   78|  43.4k|            catch( ... ) {
   79|  43.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  43.4k|               throw;
   81|  43.4k|            }
   82|  43.4k|         }
   83|  43.4k|         else {
   84|  43.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENSA_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  43.4k|      {
   44|  43.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.4k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENSA_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|  43.4k|   {
  104|  43.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  43.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  43.4k|      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  43.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  43.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  43.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  43.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  43.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  43.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  43.4k|         }
  128|       |
  129|  43.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  43.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  43.4k|         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  143|  43.4k|            if constexpr( has_apply_void ) {
  144|  43.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  43.4k|            }
  146|  43.4k|            else if constexpr( has_apply_bool ) {
  147|  43.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  43.4k|            }
  149|  43.4k|            else if constexpr( has_apply0_void ) {
  150|  43.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  43.4k|            }
  152|  43.4k|            else if constexpr( has_apply0_bool ) {
  153|  43.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.4k|            }
  155|  43.4k|         }
  156|  43.4k|         if( result ) {
  157|  43.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.4k|         }
  159|  43.4k|         else {
  160|  43.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.4k|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENSA_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  43.4k|      {
   44|  43.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.4k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  38.5k|   {
  104|  38.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  38.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  38.5k|      }
  107|  38.5k|      else {
  108|  38.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  38.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  38.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  38.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  38.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  38.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  38.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  38.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  38.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  38.5k|         }
  128|       |
  129|  38.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  38.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  38.5k|         }
  132|       |
  133|  38.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  38.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.5k, False: 10.0k]
  ------------------
  143|  28.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  28.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.5k|            }
  146|  28.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  28.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.5k|            }
  149|  28.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  28.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.5k|            }
  152|  28.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  28.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.5k|            }
  155|  28.5k|         }
  156|  38.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.5k, False: 10.0k]
  ------------------
  157|  28.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.5k|         }
  159|  10.0k|         else {
  160|  10.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.0k|         }
  162|  38.5k|         (void)m( result );
  163|  38.5k|         return result;
  164|  38.5k|      }
  165|  38.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  38.5k|      {
   73|  38.5k|#if defined( __cpp_exceptions )
   74|  38.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  38.5k|            try {
   76|  38.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  38.5k|            }
   78|  38.5k|            catch( ... ) {
   79|  38.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  38.5k|               throw;
   81|  38.5k|            }
   82|  38.5k|         }
   83|  38.5k|         else {
   84|  38.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.5k|      {
   44|  38.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.1k|   {
  104|  44.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  44.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  44.1k|      }
  107|  44.1k|      else {
  108|  44.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  44.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  44.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  44.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  44.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  44.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  44.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  44.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  44.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  44.1k|         }
  128|       |
  129|  44.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  44.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  44.1k|         }
  132|       |
  133|  44.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  44.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.7k, False: 12.3k]
  ------------------
  143|  31.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  31.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  31.7k|            }
  146|  31.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  31.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  31.7k|            }
  149|  31.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  31.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  31.7k|            }
  152|  31.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  31.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.7k|            }
  155|  31.7k|         }
  156|  44.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.7k, False: 12.3k]
  ------------------
  157|  31.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.7k|         }
  159|  12.3k|         else {
  160|  12.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.3k|         }
  162|  44.1k|         (void)m( result );
  163|  44.1k|         return result;
  164|  44.1k|      }
  165|  44.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.1k|      {
   73|  44.1k|#if defined( __cpp_exceptions )
   74|  44.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  44.1k|            try {
   76|  44.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  44.1k|            }
   78|  44.1k|            catch( ... ) {
   79|  44.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  44.1k|               throw;
   81|  44.1k|            }
   82|  44.1k|         }
   83|  44.1k|         else {
   84|  44.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.1k|      {
   44|  44.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.1k|   {
  104|  44.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  44.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  44.1k|      }
  107|  44.1k|      else {
  108|  44.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  44.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  44.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  44.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  44.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  44.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  44.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  44.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  44.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  44.1k|         }
  128|       |
  129|  44.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  44.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  44.1k|         }
  132|       |
  133|  44.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  44.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.38k, False: 41.7k]
  ------------------
  143|  2.38k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.38k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.38k|            }
  146|  2.38k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.38k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.38k|            }
  149|  2.38k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.38k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.38k|            }
  152|  2.38k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.38k|            }
  155|  2.38k|         }
  156|  44.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.38k, False: 41.7k]
  ------------------
  157|  2.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.38k|         }
  159|  41.7k|         else {
  160|  41.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.7k|         }
  162|  44.1k|         (void)m( result );
  163|  44.1k|         return result;
  164|  44.1k|      }
  165|  44.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.1k|      {
   73|  44.1k|#if defined( __cpp_exceptions )
   74|  44.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  44.1k|            try {
   76|  44.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  44.1k|            }
   78|  44.1k|            catch( ... ) {
   79|  44.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  44.1k|               throw;
   81|  44.1k|            }
   82|  44.1k|         }
   83|  44.1k|         else {
   84|  44.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.1k|      {
   44|  44.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.1k|   {
  104|  44.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  44.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  44.1k|      }
  107|  44.1k|      else {
  108|  44.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  44.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  44.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  44.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  44.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  44.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  44.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  44.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  44.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  44.1k|         }
  128|       |
  129|  44.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  44.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  44.1k|         }
  132|       |
  133|  44.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  44.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.38k, False: 41.7k]
  ------------------
  143|  2.38k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.38k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.38k|            }
  146|  2.38k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.38k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.38k|            }
  149|  2.38k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.38k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.38k|            }
  152|  2.38k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.38k|            }
  155|  2.38k|         }
  156|  44.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.38k, False: 41.7k]
  ------------------
  157|  2.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.38k|         }
  159|  41.7k|         else {
  160|  41.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.7k|         }
  162|  44.1k|         (void)m( result );
  163|  44.1k|         return result;
  164|  44.1k|      }
  165|  44.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_6str_idENS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.1k|      {
   73|  44.1k|#if defined( __cpp_exceptions )
   74|  44.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  44.1k|            try {
   76|  44.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  44.1k|            }
   78|  44.1k|            catch( ... ) {
   79|  44.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  44.1k|               throw;
   81|  44.1k|            }
   82|  44.1k|         }
   83|  44.1k|         else {
   84|  44.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_6str_idENS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.1k|      {
   44|  44.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.1k|   {
  104|  44.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  44.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  44.1k|      }
  107|  44.1k|      else {
  108|  44.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  44.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  44.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  44.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  44.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  44.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  44.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  44.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  44.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  44.1k|         }
  128|       |
  129|  44.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  44.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  44.1k|         }
  132|       |
  133|  44.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  44.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.83k, False: 41.2k]
  ------------------
  143|  2.83k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.83k|            }
  146|  2.83k|            else if constexpr( has_apply_bool ) {
  147|  2.83k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.83k|            }
  149|  2.83k|            else if constexpr( has_apply0_void ) {
  150|  2.83k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.83k|            }
  152|  2.83k|            else if constexpr( has_apply0_bool ) {
  153|  2.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.83k|            }
  155|  2.83k|         }
  156|  44.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.83k, False: 41.2k]
  ------------------
  157|  2.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.83k|         }
  159|  41.2k|         else {
  160|  41.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.2k|         }
  162|  44.1k|         (void)m( result );
  163|  44.1k|         return result;
  164|  44.1k|      }
  165|  44.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.1k|      {
   73|  44.1k|#if defined( __cpp_exceptions )
   74|  44.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  44.1k|            try {
   76|  44.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  44.1k|            }
   78|  44.1k|            catch( ... ) {
   79|  44.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  44.1k|               throw;
   81|  44.1k|            }
   82|  44.1k|         }
   83|  44.1k|         else {
   84|  44.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  44.1k|      {
   59|  44.1k|         return Rule::match( in );
   60|  44.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   728k|   {
  104|   728k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   728k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   728k|      }
  107|   728k|      else {
  108|   728k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   728k|         using iterator_t = typename ParseInput::iterator_t;
  111|   728k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   728k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   728k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   728k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   728k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   728k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   728k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   728k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   728k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   728k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   728k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   728k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   728k|         }
  128|       |
  129|   728k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   728k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   728k|         }
  132|       |
  133|   728k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   728k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   728k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   728k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   728k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   728k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   728k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   728k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 726k, False: 1.46k]
  ------------------
  143|   726k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   726k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   726k|            }
  146|   726k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   726k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   726k|            }
  149|   726k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   726k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   726k|            }
  152|   726k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   726k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   726k|            }
  155|   726k|         }
  156|   728k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 726k, False: 1.46k]
  ------------------
  157|   726k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   726k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|   728k|         (void)m( result );
  163|   728k|         return result;
  164|   728k|      }
  165|   728k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   728k|      {
   73|   728k|#if defined( __cpp_exceptions )
   74|   728k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   728k|            try {
   76|   728k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   728k|            }
   78|   728k|            catch( ... ) {
   79|   728k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   728k|               throw;
   81|   728k|            }
   82|   728k|         }
   83|   728k|         else {
   84|   728k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   728k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   728k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   728k|      {
   44|   728k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   728k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   728k|   {
  104|   728k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   728k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   728k|      }
  107|   728k|      else {
  108|   728k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   728k|         using iterator_t = typename ParseInput::iterator_t;
  111|   728k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   728k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   728k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   728k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   728k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   728k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   728k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   728k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   728k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   728k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   728k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   728k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   728k|         }
  128|       |
  129|   728k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   728k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   728k|         }
  132|       |
  133|   728k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   728k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   728k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   728k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   728k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   728k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   728k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   728k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 726k, False: 1.46k]
  ------------------
  143|   726k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   726k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   726k|            }
  146|   726k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   726k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   726k|            }
  149|   726k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   726k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   726k|            }
  152|   726k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   726k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   726k|            }
  155|   726k|         }
  156|   728k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 726k, False: 1.46k]
  ------------------
  157|   726k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   726k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|   728k|         (void)m( result );
  163|   728k|         return result;
  164|   728k|      }
  165|   728k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   728k|      {
   73|   728k|#if defined( __cpp_exceptions )
   74|   728k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   728k|            try {
   76|   728k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   728k|            }
   78|   728k|            catch( ... ) {
   79|   728k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   728k|               throw;
   81|   728k|            }
   82|   728k|         }
   83|   728k|         else {
   84|   728k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   728k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   728k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   728k|      {
   59|   728k|         return Rule::match( in );
   60|   728k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   737k|   {
  104|   737k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   737k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   737k|      }
  107|   737k|      else {
  108|   737k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   737k|         using iterator_t = typename ParseInput::iterator_t;
  111|   737k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   737k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   737k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   737k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   737k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   737k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   737k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   737k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   737k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   737k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   737k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   737k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   737k|         }
  128|       |
  129|   737k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   737k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   737k|         }
  132|       |
  133|   737k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   737k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   737k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   737k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   737k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   737k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   737k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   737k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.53k, False: 731k]
  ------------------
  143|  6.53k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.53k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.53k|            }
  146|  6.53k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.53k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.53k|            }
  149|  6.53k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.53k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.53k|            }
  152|  6.53k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.53k|            }
  155|  6.53k|         }
  156|   737k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.53k, False: 731k]
  ------------------
  157|  6.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.53k|         }
  159|   731k|         else {
  160|   731k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   731k|         }
  162|   737k|         (void)m( result );
  163|   737k|         return result;
  164|   737k|      }
  165|   737k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   737k|      {
   73|   737k|#if defined( __cpp_exceptions )
   74|   737k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   737k|            try {
   76|   737k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   737k|            }
   78|   737k|            catch( ... ) {
   79|   737k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   737k|               throw;
   81|   737k|            }
   82|   737k|         }
   83|   737k|         else {
   84|   737k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   737k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   737k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   737k|      {
   59|   737k|         return Rule::match( in );
   60|   737k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.38k, False: 434]
  ------------------
  143|  2.38k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.38k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.38k|            }
  146|  2.38k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.38k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.38k|            }
  149|  2.38k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.38k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.38k|            }
  152|  2.38k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.38k|            }
  155|  2.38k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.38k, False: 434]
  ------------------
  157|  2.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.38k|         }
  159|    434|         else {
  160|    434|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    434|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15device_id_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15device_id_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.81k|      {
   44|  2.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.03k, False: 781]
  ------------------
  143|  2.03k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.03k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.03k|            }
  146|  2.03k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.03k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.03k|            }
  149|  2.03k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.03k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.03k|            }
  152|  2.03k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.03k|            }
  155|  2.03k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.03k, False: 781]
  ------------------
  157|  2.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.03k|         }
  159|    781|         else {
  160|    781|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    781|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.81k|      {
   44|  2.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.81k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.81k, False: 0]
  ------------------
  143|  2.81k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.81k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.81k|            }
  146|  2.81k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.81k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.81k|            }
  149|  2.81k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.81k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.81k|            }
  152|  2.81k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.81k|            }
  155|  2.81k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.81k, False: 0]
  ------------------
  157|  2.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.81k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.81k|      {
   44|  2.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.81k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  143|  2.81k|            if constexpr( has_apply_void ) {
  144|  2.81k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.81k|            }
  146|  2.81k|            else if constexpr( has_apply_bool ) {
  147|  2.81k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.81k|            }
  149|  2.81k|            else if constexpr( has_apply0_void ) {
  150|  2.81k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.81k|            }
  152|  2.81k|            else if constexpr( has_apply0_bool ) {
  153|  2.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.81k|            }
  155|  2.81k|         }
  156|  2.81k|         if( result ) {
  157|  2.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.81k|         }
  159|  2.81k|         else {
  160|  2.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.81k|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.81k|      {
   44|  2.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.22k, False: 1.59k]
  ------------------
  143|  1.22k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.22k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.22k|            }
  146|  1.22k|            else if constexpr( has_apply_bool ) {
  147|  1.22k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.22k|            }
  149|  1.22k|            else if constexpr( has_apply0_void ) {
  150|  1.22k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.22k|            }
  152|  1.22k|            else if constexpr( has_apply0_bool ) {
  153|  1.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.22k|            }
  155|  1.22k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.22k, False: 1.59k]
  ------------------
  157|  1.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.22k|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.81k|      {
   44|  2.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 208, False: 2.60k]
  ------------------
  143|    208|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    208|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    208|            }
  146|    208|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    208|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    208|            }
  149|    208|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    208|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    208|            }
  152|    208|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    208|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    208|            }
  155|    208|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 208, False: 2.60k]
  ------------------
  157|    208|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    208|         }
  159|  2.60k|         else {
  160|  2.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.60k|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.81k|      {
   59|  2.81k|         return Rule::match( in );
   60|  2.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.60k|   {
  104|  2.60k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.60k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.60k|      }
  107|  2.60k|      else {
  108|  2.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.60k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.60k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.60k|         }
  128|       |
  129|  2.60k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.60k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.60k|         }
  132|       |
  133|  2.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.60k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 204, False: 2.40k]
  ------------------
  143|    204|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    204|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    204|            }
  146|    204|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    204|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    204|            }
  149|    204|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    204|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    204|            }
  152|    204|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    204|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    204|            }
  155|    204|         }
  156|  2.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 204, False: 2.40k]
  ------------------
  157|    204|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    204|         }
  159|  2.40k|         else {
  160|  2.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.40k|         }
  162|  2.60k|         (void)m( result );
  163|  2.60k|         return result;
  164|  2.60k|      }
  165|  2.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.60k|      {
   73|  2.60k|#if defined( __cpp_exceptions )
   74|  2.60k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.60k|            try {
   76|  2.60k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.60k|            }
   78|  2.60k|            catch( ... ) {
   79|  2.60k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.60k|               throw;
   81|  2.60k|            }
   82|  2.60k|         }
   83|  2.60k|         else {
   84|  2.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.60k|      {
   59|  2.60k|         return Rule::match( in );
   60|  2.60k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|  2.40k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.40k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.40k|      }
  107|  2.40k|      else {
  108|  2.40k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.40k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.40k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.40k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.40k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.40k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.40k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.40k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.40k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.40k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.40k|         }
  128|       |
  129|  2.40k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.40k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.40k|         }
  132|       |
  133|  2.40k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.40k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.40k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.40k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.40k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.40k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.40k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.40k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 2.20k]
  ------------------
  143|    197|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    197|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    197|            }
  146|    197|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    197|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    197|            }
  149|    197|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    197|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    197|            }
  152|    197|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    197|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    197|            }
  155|    197|         }
  156|  2.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.20k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.20k|         else {
  160|  2.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.20k|         }
  162|  2.40k|         (void)m( result );
  163|  2.40k|         return result;
  164|  2.40k|      }
  165|  2.40k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.40k|      {
   73|  2.40k|#if defined( __cpp_exceptions )
   74|  2.40k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.40k|            try {
   76|  2.40k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.40k|            }
   78|  2.40k|            catch( ... ) {
   79|  2.40k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.40k|               throw;
   81|  2.40k|            }
   82|  2.40k|         }
   83|  2.40k|         else {
   84|  2.40k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.40k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.40k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.40k|      {
   59|  2.40k|         return Rule::match( in );
   60|  2.40k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.20k|   {
  104|  2.20k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.20k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.20k|      }
  107|  2.20k|      else {
  108|  2.20k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.20k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.20k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.20k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.20k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.20k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.20k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.20k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.20k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.20k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.20k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.20k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.20k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.20k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.20k|         }
  128|       |
  129|  2.20k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.20k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.20k|         }
  132|       |
  133|  2.20k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.20k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.20k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.20k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.20k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.20k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.20k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.20k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.01k]
  ------------------
  143|    194|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    194|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    194|            }
  146|    194|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    194|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    194|            }
  149|    194|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    194|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    194|            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  2.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.01k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.01k|         else {
  160|  2.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.01k|         }
  162|  2.20k|         (void)m( result );
  163|  2.20k|         return result;
  164|  2.20k|      }
  165|  2.20k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.20k|      {
   73|  2.20k|#if defined( __cpp_exceptions )
   74|  2.20k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.20k|            try {
   76|  2.20k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.20k|            }
   78|  2.20k|            catch( ... ) {
   79|  2.20k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.20k|               throw;
   81|  2.20k|            }
   82|  2.20k|         }
   83|  2.20k|         else {
   84|  2.20k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.20k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.20k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.20k|      {
   59|  2.20k|         return Rule::match( in );
   60|  2.20k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.01k|   {
  104|  2.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.01k|      }
  107|  2.01k|      else {
  108|  2.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.01k|         }
  128|       |
  129|  2.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.01k|         }
  132|       |
  133|  2.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 224, False: 1.78k]
  ------------------
  143|    224|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    224|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    224|            }
  146|    224|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    224|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    224|            }
  149|    224|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    224|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    224|            }
  152|    224|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    224|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    224|            }
  155|    224|         }
  156|  2.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 1.78k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  159|  1.78k|         else {
  160|  1.78k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.78k|         }
  162|  2.01k|         (void)m( result );
  163|  2.01k|         return result;
  164|  2.01k|      }
  165|  2.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.01k|      {
   73|  2.01k|#if defined( __cpp_exceptions )
   74|  2.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.01k|            try {
   76|  2.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.01k|            }
   78|  2.01k|            catch( ... ) {
   79|  2.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.01k|               throw;
   81|  2.01k|            }
   82|  2.01k|         }
   83|  2.01k|         else {
   84|  2.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.01k|      {
   59|  2.01k|         return Rule::match( in );
   60|  2.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.78k|   {
  104|  1.78k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.78k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.78k|      }
  107|  1.78k|      else {
  108|  1.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.78k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.78k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.78k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.78k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.78k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.78k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.78k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.78k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.78k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.78k|         }
  128|       |
  129|  1.78k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.78k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.78k|         }
  132|       |
  133|  1.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.78k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 1.59k]
  ------------------
  143|    196|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    196|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    196|            }
  146|    196|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    196|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    196|            }
  149|    196|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    196|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    196|            }
  152|    196|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    196|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    196|            }
  155|    196|         }
  156|  1.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 1.59k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  1.78k|         (void)m( result );
  163|  1.78k|         return result;
  164|  1.78k|      }
  165|  1.78k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.78k|      {
   73|  1.78k|#if defined( __cpp_exceptions )
   74|  1.78k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.78k|            try {
   76|  1.78k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.78k|            }
   78|  1.78k|            catch( ... ) {
   79|  1.78k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.78k|               throw;
   81|  1.78k|            }
   82|  1.78k|         }
   83|  1.78k|         else {
   84|  1.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.78k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.78k|      {
   59|  1.78k|         return Rule::match( in );
   60|  1.78k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|  2.81k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.81k|      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.81k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.81k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.81k|         }
  128|       |
  129|  2.81k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.81k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.81k|         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.27k, False: 544]
  ------------------
  143|  2.27k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.27k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.27k|            }
  146|  2.27k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.27k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.27k|            }
  149|  2.27k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.27k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.27k|            }
  152|  2.27k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.27k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.27k|            }
  155|  2.27k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.27k, False: 544]
  ------------------
  157|  2.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.27k|         }
  159|    544|         else {
  160|    544|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    544|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|  2.81k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.81k|            try {
   76|  2.81k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.81k|            }
   78|  2.81k|            catch( ... ) {
   79|  2.81k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.81k|               throw;
   81|  2.81k|            }
   82|  2.81k|         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.81k|      {
   59|  2.81k|         return Rule::match( in );
   60|  2.81k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.48k|   {
  104|  4.48k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.48k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.48k|      }
  107|  4.48k|      else {
  108|  4.48k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.48k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.48k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.48k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.48k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.48k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.48k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.48k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.48k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.48k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.48k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.48k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.48k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.48k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.48k|         }
  128|       |
  129|  4.48k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.48k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.48k|         }
  132|       |
  133|  4.48k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.48k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.48k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.48k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.48k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.48k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.48k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.48k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.48k, False: 0]
  ------------------
  143|  4.48k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.48k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.48k|            }
  146|  4.48k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.48k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.48k|            }
  149|  4.48k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.48k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.48k|            }
  152|  4.48k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.48k|            }
  155|  4.48k|         }
  156|  4.48k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.48k, False: 0]
  ------------------
  157|  4.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.48k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.48k|         (void)m( result );
  163|  4.48k|         return result;
  164|  4.48k|      }
  165|  4.48k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.48k|      {
   73|  4.48k|#if defined( __cpp_exceptions )
   74|  4.48k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.48k|            try {
   76|  4.48k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.48k|            }
   78|  4.48k|            catch( ... ) {
   79|  4.48k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.48k|               throw;
   81|  4.48k|            }
   82|  4.48k|         }
   83|  4.48k|         else {
   84|  4.48k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.48k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.48k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.48k|      {
   44|  4.48k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.48k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.27k|   {
  104|  2.27k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.27k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.27k|      }
  107|  2.27k|      else {
  108|  2.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.27k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.27k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.27k|         }
  128|       |
  129|  2.27k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.27k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.27k|         }
  132|       |
  133|  2.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.21k, False: 59]
  ------------------
  143|  2.21k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.21k|            }
  146|  2.21k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.21k|            }
  149|  2.21k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.21k|            }
  152|  2.21k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.21k|            }
  155|  2.21k|         }
  156|  2.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.21k, False: 59]
  ------------------
  157|  2.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.21k|         }
  159|     59|         else {
  160|     59|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     59|         }
  162|  2.27k|         (void)m( result );
  163|  2.27k|         return result;
  164|  2.27k|      }
  165|  2.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.27k|      {
   73|  2.27k|#if defined( __cpp_exceptions )
   74|  2.27k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.27k|            try {
   76|  2.27k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.27k|            }
   78|  2.27k|            catch( ... ) {
   79|  2.27k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.27k|               throw;
   81|  2.27k|            }
   82|  2.27k|         }
   83|  2.27k|         else {
   84|  2.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.27k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.27k|      {
   44|  2.27k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.27k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.21k|   {
  104|  2.21k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.21k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.21k|      }
  107|  2.21k|      else {
  108|  2.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  2.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  2.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  2.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  2.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  2.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  2.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.21k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  2.21k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.21k|         }
  128|       |
  129|  2.21k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  2.21k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.21k|         }
  132|       |
  133|  2.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  2.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.21k|         if( result ) {
  143|  2.21k|            if constexpr( has_apply_void ) {
  144|  2.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.21k|            }
  146|  2.21k|            else if constexpr( has_apply_bool ) {
  147|  2.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.21k|            }
  149|  2.21k|            else if constexpr( has_apply0_void ) {
  150|  2.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.21k|            }
  152|  2.21k|            else if constexpr( has_apply0_bool ) {
  153|  2.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.21k|            }
  155|  2.21k|         }
  156|  2.21k|         if( result ) {
  157|  2.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.21k|         }
  159|  2.21k|         else {
  160|  2.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.21k|         }
  162|  2.21k|         (void)m( result );
  163|  2.21k|         return result;
  164|  2.21k|      }
  165|  2.21k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.21k|      {
   44|  2.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.21k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   724k|   {
  104|   724k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   724k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   724k|      }
  107|   724k|      else {
  108|   724k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   724k|         using iterator_t = typename ParseInput::iterator_t;
  111|   724k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   724k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   724k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   724k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   724k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   724k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   724k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   724k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   724k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   724k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   724k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   724k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   724k|         }
  128|       |
  129|   724k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   724k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   724k|         }
  132|       |
  133|   724k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   724k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   724k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   724k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   724k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   724k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   724k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   724k|         if( result ) {
  143|   724k|            if constexpr( has_apply_void ) {
  144|   724k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   724k|            }
  146|   724k|            else if constexpr( has_apply_bool ) {
  147|   724k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   724k|            }
  149|   724k|            else if constexpr( has_apply0_void ) {
  150|   724k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   724k|            }
  152|   724k|            else if constexpr( has_apply0_bool ) {
  153|   724k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   724k|            }
  155|   724k|         }
  156|   724k|         if( result ) {
  157|   724k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   724k|         }
  159|   724k|         else {
  160|   724k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   724k|         }
  162|   724k|         (void)m( result );
  163|   724k|         return result;
  164|   724k|      }
  165|   724k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   724k|      {
   44|   724k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   724k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.21k|   {
  104|  2.21k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.21k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.21k|      }
  107|  2.21k|      else {
  108|  2.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.21k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.21k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.21k|         }
  128|       |
  129|  2.21k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.21k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.21k|         }
  132|       |
  133|  2.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.03k, False: 178]
  ------------------
  143|  2.03k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.03k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.03k|            }
  146|  2.03k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.03k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.03k|            }
  149|  2.03k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.03k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.03k|            }
  152|  2.03k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.03k|            }
  155|  2.03k|         }
  156|  2.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.03k, False: 178]
  ------------------
  157|  2.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.03k|         }
  159|    178|         else {
  160|    178|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    178|         }
  162|  2.21k|         (void)m( result );
  163|  2.21k|         return result;
  164|  2.21k|      }
  165|  2.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.21k|      {
   73|  2.21k|#if defined( __cpp_exceptions )
   74|  2.21k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.21k|            try {
   76|  2.21k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.21k|            }
   78|  2.21k|            catch( ... ) {
   79|  2.21k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.21k|               throw;
   81|  2.21k|            }
   82|  2.21k|         }
   83|  2.21k|         else {
   84|  2.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.21k|      {
   59|  2.21k|         return Rule::match( in );
   60|  2.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   725k|   {
  104|   725k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   725k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   725k|      }
  107|   725k|      else {
  108|   725k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   725k|         using iterator_t = typename ParseInput::iterator_t;
  111|   725k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   725k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   725k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   725k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   725k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   725k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   725k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   725k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   725k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   725k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   725k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   725k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   725k|         }
  128|       |
  129|   725k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   725k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   725k|         }
  132|       |
  133|   725k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   725k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   725k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   725k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   725k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   725k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   725k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   725k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 724k, False: 1.29k]
  ------------------
  143|   724k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   724k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   724k|            }
  146|   724k|            else if constexpr( has_apply_bool ) {
  147|   724k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   724k|            }
  149|   724k|            else if constexpr( has_apply0_void ) {
  150|   724k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   724k|            }
  152|   724k|            else if constexpr( has_apply0_bool ) {
  153|   724k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   724k|            }
  155|   724k|         }
  156|   725k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 724k, False: 1.29k]
  ------------------
  157|   724k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   724k|         }
  159|  1.29k|         else {
  160|  1.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.29k|         }
  162|   725k|         (void)m( result );
  163|   725k|         return result;
  164|   725k|      }
  165|   725k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   725k|      {
   73|   725k|#if defined( __cpp_exceptions )
   74|   725k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   725k|            try {
   76|   725k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   725k|            }
   78|   725k|            catch( ... ) {
   79|   725k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   725k|               throw;
   81|   725k|            }
   82|   725k|         }
   83|   725k|         else {
   84|   725k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   725k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   725k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   725k|      {
   44|   725k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   725k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   725k|   {
  104|   725k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   725k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   725k|      }
  107|   725k|      else {
  108|   725k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   725k|         using iterator_t = typename ParseInput::iterator_t;
  111|   725k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   725k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   725k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   725k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   725k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   725k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   725k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   725k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   725k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   725k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   725k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   725k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   725k|         }
  128|       |
  129|   725k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   725k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   725k|         }
  132|       |
  133|   725k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   725k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   725k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   725k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   725k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   725k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   725k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   725k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 724k, False: 1.23k]
  ------------------
  143|   724k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   724k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   724k|            }
  146|   724k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   724k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   724k|            }
  149|   724k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   724k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   724k|            }
  152|   724k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   724k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   724k|            }
  155|   724k|         }
  156|   725k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 724k, False: 1.23k]
  ------------------
  157|   724k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   724k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|   725k|         (void)m( result );
  163|   725k|         return result;
  164|   725k|      }
  165|   725k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   725k|      {
   73|   725k|#if defined( __cpp_exceptions )
   74|   725k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   725k|            try {
   76|   725k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   725k|            }
   78|   725k|            catch( ... ) {
   79|   725k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   725k|               throw;
   81|   725k|            }
   82|   725k|         }
   83|   725k|         else {
   84|   725k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   725k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   725k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   725k|      {
   44|   725k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   725k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.45M|   {
  104|  1.45M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.45M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.45M|      }
  107|  1.45M|      else {
  108|  1.45M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.45M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.45M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.45M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.45M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.45M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.45M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.45M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.45M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.45M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.45M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.45M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.45M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.45M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.45M|         }
  128|       |
  129|  1.45M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.45M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.45M|         }
  132|       |
  133|  1.45M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.45M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.45M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.45M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.45M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.45M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.45M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.45M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.52k, False: 1.44M]
  ------------------
  143|  1.52k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.52k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.52k|            }
  146|  1.52k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.52k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.52k|            }
  149|  1.52k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.52k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.52k|            }
  152|  1.52k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.52k|            }
  155|  1.52k|         }
  156|  1.45M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.52k, False: 1.44M]
  ------------------
  157|  1.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.52k|         }
  159|  1.44M|         else {
  160|  1.44M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.44M|         }
  162|  1.45M|         (void)m( result );
  163|  1.45M|         return result;
  164|  1.45M|      }
  165|  1.45M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.45M|      {
   73|  1.45M|#if defined( __cpp_exceptions )
   74|  1.45M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.45M|            try {
   76|  1.45M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.45M|            }
   78|  1.45M|            catch( ... ) {
   79|  1.45M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.45M|               throw;
   81|  1.45M|            }
   82|  1.45M|         }
   83|  1.45M|         else {
   84|  1.45M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.45M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.45M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.45M|      {
   44|  1.45M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.45M|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.45M|   {
  104|  1.45M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.45M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.45M|      }
  107|  1.45M|      else {
  108|  1.45M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.45M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.45M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.45M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.45M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.45M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.45M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.45M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.45M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.45M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.45M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.45M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.45M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.45M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.45M|         }
  128|       |
  129|  1.45M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.45M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.45M|         }
  132|       |
  133|  1.45M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.45M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.45M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.45M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.45M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.45M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.45M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.45M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.24k, False: 1.44M]
  ------------------
  143|  6.24k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.24k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.24k|            }
  146|  6.24k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.24k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.24k|            }
  149|  6.24k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.24k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.24k|            }
  152|  6.24k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.24k|            }
  155|  6.24k|         }
  156|  1.45M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.24k, False: 1.44M]
  ------------------
  157|  6.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.24k|         }
  159|  1.44M|         else {
  160|  1.44M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.44M|         }
  162|  1.45M|         (void)m( result );
  163|  1.45M|         return result;
  164|  1.45M|      }
  165|  1.45M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  1.45M|      {
   73|  1.45M|#if defined( __cpp_exceptions )
   74|  1.45M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.45M|            try {
   76|  1.45M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.45M|            }
   78|  1.45M|            catch( ... ) {
   79|  1.45M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.45M|               throw;
   81|  1.45M|            }
   82|  1.45M|         }
   83|  1.45M|         else {
   84|  1.45M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.45M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.45M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.45M|      {
   59|  1.45M|         return Rule::match( in );
   60|  1.45M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.44M|   {
  104|  1.44M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.44M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.44M|      }
  107|  1.44M|      else {
  108|  1.44M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.44M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.44M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.44M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.44M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.44M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.44M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.44M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.44M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.44M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.44M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.44M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.44M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.44M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.44M|         }
  128|       |
  129|  1.44M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.44M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.44M|         }
  132|       |
  133|  1.44M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.44M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.44M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.44M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.44M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.44M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.44M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.44M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44M, False: 1.26k]
  ------------------
  143|  1.44M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.44M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.44M|            }
  146|  1.44M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.44M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.44M|            }
  149|  1.44M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.44M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.44M|            }
  152|  1.44M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.44M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.44M|            }
  155|  1.44M|         }
  156|  1.44M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44M, False: 1.26k]
  ------------------
  157|  1.44M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44M|         }
  159|  1.26k|         else {
  160|  1.26k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.26k|         }
  162|  1.44M|         (void)m( result );
  163|  1.44M|         return result;
  164|  1.44M|      }
  165|  1.44M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.44M|      {
   73|  1.44M|#if defined( __cpp_exceptions )
   74|  1.44M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.44M|            try {
   76|  1.44M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.44M|            }
   78|  1.44M|            catch( ... ) {
   79|  1.44M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.44M|               throw;
   81|  1.44M|            }
   82|  1.44M|         }
   83|  1.44M|         else {
   84|  1.44M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.44M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.44M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.44M|      {
   59|  1.44M|         return Rule::match( in );
   60|  1.44M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   724k|   {
  104|   724k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   724k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   724k|      }
  107|   724k|      else {
  108|   724k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   724k|         using iterator_t = typename ParseInput::iterator_t;
  111|   724k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   724k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   724k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   724k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   724k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   724k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   724k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   724k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   724k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   724k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   724k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   724k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   724k|         }
  128|       |
  129|   724k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   724k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   724k|         }
  132|       |
  133|   724k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   724k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   724k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   724k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   724k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   724k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   724k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   724k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 724k, False: 34]
  ------------------
  143|   724k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   724k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   724k|            }
  146|   724k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   724k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   724k|            }
  149|   724k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   724k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   724k|            }
  152|   724k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   724k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   724k|            }
  155|   724k|         }
  156|   724k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 724k, False: 34]
  ------------------
  157|   724k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   724k|         }
  159|     34|         else {
  160|     34|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     34|         }
  162|   724k|         (void)m( result );
  163|   724k|         return result;
  164|   724k|      }
  165|   724k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   724k|      {
   73|   724k|#if defined( __cpp_exceptions )
   74|   724k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   724k|            try {
   76|   724k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   724k|            }
   78|   724k|            catch( ... ) {
   79|   724k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   724k|               throw;
   81|   724k|            }
   82|   724k|         }
   83|   724k|         else {
   84|   724k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   724k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   724k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   724k|      {
   59|   724k|         return Rule::match( in );
   60|   724k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   724k|   {
  104|   724k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   724k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   724k|      }
  107|   724k|      else {
  108|   724k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   724k|         using iterator_t = typename ParseInput::iterator_t;
  111|   724k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   724k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   724k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   724k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   724k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   724k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   724k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   724k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   724k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   724k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   724k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   724k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   724k|         }
  128|       |
  129|   724k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   724k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   724k|         }
  132|       |
  133|   724k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   724k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   724k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   724k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   724k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   724k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   724k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   724k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 724k, False: 30]
  ------------------
  143|   724k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   724k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   724k|            }
  146|   724k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   724k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   724k|            }
  149|   724k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   724k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   724k|            }
  152|   724k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   724k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   724k|            }
  155|   724k|         }
  156|   724k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 724k, False: 30]
  ------------------
  157|   724k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   724k|         }
  159|     30|         else {
  160|     30|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     30|         }
  162|   724k|         (void)m( result );
  163|   724k|         return result;
  164|   724k|      }
  165|   724k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   724k|      {
   73|   724k|#if defined( __cpp_exceptions )
   74|   724k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   724k|            try {
   76|   724k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   724k|            }
   78|   724k|            catch( ... ) {
   79|   724k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   724k|               throw;
   81|   724k|            }
   82|   724k|         }
   83|   724k|         else {
   84|   724k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   724k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   724k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   724k|      {
   44|   724k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   724k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.7k|   {
  104|  41.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  41.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  41.7k|      }
  107|  41.7k|      else {
  108|  41.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  41.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  41.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  41.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  41.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  41.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  41.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  41.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  41.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  41.7k|         }
  128|       |
  129|  41.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  41.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  41.7k|         }
  132|       |
  133|  41.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  41.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.20k, False: 37.5k]
  ------------------
  143|  4.20k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.20k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.20k|            }
  146|  4.20k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.20k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.20k|            }
  149|  4.20k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.20k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.20k|            }
  152|  4.20k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.20k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.20k|            }
  155|  4.20k|         }
  156|  41.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.20k, False: 37.5k]
  ------------------
  157|  4.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.20k|         }
  159|  37.5k|         else {
  160|  37.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.5k|         }
  162|  41.7k|         (void)m( result );
  163|  41.7k|         return result;
  164|  41.7k|      }
  165|  41.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.7k|      {
   73|  41.7k|#if defined( __cpp_exceptions )
   74|  41.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  41.7k|            try {
   76|  41.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  41.7k|            }
   78|  41.7k|            catch( ... ) {
   79|  41.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  41.7k|               throw;
   81|  41.7k|            }
   82|  41.7k|         }
   83|  41.7k|         else {
   84|  41.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.7k|      {
   44|  41.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.7k|   {
  104|  41.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  41.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  41.7k|      }
  107|  41.7k|      else {
  108|  41.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  41.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  41.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  41.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  41.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  41.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  41.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  41.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  41.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  41.7k|         }
  128|       |
  129|  41.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  41.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  41.7k|         }
  132|       |
  133|  41.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  41.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.20k, False: 37.5k]
  ------------------
  143|  4.20k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.20k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.20k|            }
  146|  4.20k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.20k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.20k|            }
  149|  4.20k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.20k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.20k|            }
  152|  4.20k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.20k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.20k|            }
  155|  4.20k|         }
  156|  41.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.20k, False: 37.5k]
  ------------------
  157|  4.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.20k|         }
  159|  37.5k|         else {
  160|  37.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.5k|         }
  162|  41.7k|         (void)m( result );
  163|  41.7k|         return result;
  164|  41.7k|      }
  165|  41.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_8str_nameENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.7k|      {
   73|  41.7k|#if defined( __cpp_exceptions )
   74|  41.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  41.7k|            try {
   76|  41.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  41.7k|            }
   78|  41.7k|            catch( ... ) {
   79|  41.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  41.7k|               throw;
   81|  41.7k|            }
   82|  41.7k|         }
   83|  41.7k|         else {
   84|  41.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_8str_nameENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.7k|      {
   44|  41.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.7k|   {
  104|  41.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  41.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  41.7k|      }
  107|  41.7k|      else {
  108|  41.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  41.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  41.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  41.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  41.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  41.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  41.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  41.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  41.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  41.7k|         }
  128|       |
  129|  41.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  41.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  41.7k|         }
  132|       |
  133|  41.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  41.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.91k, False: 36.8k]
  ------------------
  143|  4.91k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.91k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.91k|            }
  146|  4.91k|            else if constexpr( has_apply_bool ) {
  147|  4.91k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.91k|            }
  149|  4.91k|            else if constexpr( has_apply0_void ) {
  150|  4.91k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.91k|            }
  152|  4.91k|            else if constexpr( has_apply0_bool ) {
  153|  4.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.91k|            }
  155|  4.91k|         }
  156|  41.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.91k, False: 36.8k]
  ------------------
  157|  4.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.91k|         }
  159|  36.8k|         else {
  160|  36.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.8k|         }
  162|  41.7k|         (void)m( result );
  163|  41.7k|         return result;
  164|  41.7k|      }
  165|  41.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.7k|      {
   73|  41.7k|#if defined( __cpp_exceptions )
   74|  41.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  41.7k|            try {
   76|  41.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  41.7k|            }
   78|  41.7k|            catch( ... ) {
   79|  41.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  41.7k|               throw;
   81|  41.7k|            }
   82|  41.7k|         }
   83|  41.7k|         else {
   84|  41.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  41.7k|      {
   59|  41.7k|         return Rule::match( in );
   60|  41.7k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   488k|   {
  104|   488k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   488k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   488k|      }
  107|   488k|      else {
  108|   488k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   488k|         using iterator_t = typename ParseInput::iterator_t;
  111|   488k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   488k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   488k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   488k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   488k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   488k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   488k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   488k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   488k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   488k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   488k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   488k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   488k|         }
  128|       |
  129|   488k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   488k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   488k|         }
  132|       |
  133|   488k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   488k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   488k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   488k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   488k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   488k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   488k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   488k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 486k, False: 2.29k]
  ------------------
  143|   486k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   486k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   486k|            }
  146|   486k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   486k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   486k|            }
  149|   486k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   486k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   486k|            }
  152|   486k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   486k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   486k|            }
  155|   486k|         }
  156|   488k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 486k, False: 2.29k]
  ------------------
  157|   486k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   486k|         }
  159|  2.29k|         else {
  160|  2.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.29k|         }
  162|   488k|         (void)m( result );
  163|   488k|         return result;
  164|   488k|      }
  165|   488k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   488k|      {
   73|   488k|#if defined( __cpp_exceptions )
   74|   488k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   488k|            try {
   76|   488k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   488k|            }
   78|   488k|            catch( ... ) {
   79|   488k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   488k|               throw;
   81|   488k|            }
   82|   488k|         }
   83|   488k|         else {
   84|   488k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   488k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   488k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   488k|      {
   44|   488k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   488k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   488k|   {
  104|   488k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   488k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   488k|      }
  107|   488k|      else {
  108|   488k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   488k|         using iterator_t = typename ParseInput::iterator_t;
  111|   488k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   488k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   488k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   488k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   488k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   488k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   488k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   488k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   488k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   488k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   488k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   488k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   488k|         }
  128|       |
  129|   488k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   488k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   488k|         }
  132|       |
  133|   488k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   488k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   488k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   488k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   488k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   488k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   488k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   488k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 486k, False: 2.29k]
  ------------------
  143|   486k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   486k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   486k|            }
  146|   486k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   486k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   486k|            }
  149|   486k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   486k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   486k|            }
  152|   486k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   486k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   486k|            }
  155|   486k|         }
  156|   488k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 486k, False: 2.29k]
  ------------------
  157|   486k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   486k|         }
  159|  2.29k|         else {
  160|  2.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.29k|         }
  162|   488k|         (void)m( result );
  163|   488k|         return result;
  164|   488k|      }
  165|   488k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   488k|      {
   73|   488k|#if defined( __cpp_exceptions )
   74|   488k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   488k|            try {
   76|   488k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   488k|            }
   78|   488k|            catch( ... ) {
   79|   488k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   488k|               throw;
   81|   488k|            }
   82|   488k|         }
   83|   488k|         else {
   84|   488k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   488k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   488k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   488k|      {
   59|   488k|         return Rule::match( in );
   60|   488k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   508k|   {
  104|   508k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   508k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   508k|      }
  107|   508k|      else {
  108|   508k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   508k|         using iterator_t = typename ParseInput::iterator_t;
  111|   508k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   508k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   508k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   508k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   508k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   508k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   508k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   508k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   508k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   508k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   508k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   508k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   508k|         }
  128|       |
  129|   508k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   508k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   508k|         }
  132|       |
  133|   508k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   508k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   508k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   508k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   508k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   508k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   508k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   508k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 15.8k, False: 493k]
  ------------------
  143|  15.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  15.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  15.8k|            }
  146|  15.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  15.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  15.8k|            }
  149|  15.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  15.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  15.8k|            }
  152|  15.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  15.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  15.8k|            }
  155|  15.8k|         }
  156|   508k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 15.8k, False: 493k]
  ------------------
  157|  15.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  15.8k|         }
  159|   493k|         else {
  160|   493k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   493k|         }
  162|   508k|         (void)m( result );
  163|   508k|         return result;
  164|   508k|      }
  165|   508k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   508k|      {
   73|   508k|#if defined( __cpp_exceptions )
   74|   508k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   508k|            try {
   76|   508k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   508k|            }
   78|   508k|            catch( ... ) {
   79|   508k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   508k|               throw;
   81|   508k|            }
   82|   508k|         }
   83|   508k|         else {
   84|   508k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   508k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   508k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   508k|      {
   59|   508k|         return Rule::match( in );
   60|   508k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.20k, False: 692]
  ------------------
  143|  4.20k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.20k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.20k|            }
  146|  4.20k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.20k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.20k|            }
  149|  4.20k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.20k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.20k|            }
  152|  4.20k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.20k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.20k|            }
  155|  4.20k|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.20k, False: 692]
  ------------------
  157|  4.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.20k|         }
  159|    692|         else {
  160|    692|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    692|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.89k|#if defined( __cpp_exceptions )
   74|  4.89k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.89k|            try {
   76|  4.89k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.89k|            }
   78|  4.89k|            catch( ... ) {
   79|  4.89k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.89k|               throw;
   81|  4.89k|            }
   82|  4.89k|         }
   83|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.89k|      {
   44|  4.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.13k, False: 1.75k]
  ------------------
  143|  3.13k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.13k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.13k|            }
  146|  3.13k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.13k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.13k|            }
  149|  3.13k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.13k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.13k|            }
  152|  3.13k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.13k|            }
  155|  3.13k|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.13k, False: 1.75k]
  ------------------
  157|  3.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.13k|         }
  159|  1.75k|         else {
  160|  1.75k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.75k|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.89k|#if defined( __cpp_exceptions )
   74|  4.89k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.89k|            try {
   76|  4.89k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.89k|            }
   78|  4.89k|            catch( ... ) {
   79|  4.89k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.89k|               throw;
   81|  4.89k|            }
   82|  4.89k|         }
   83|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.89k|      {
   44|  4.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.89k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.89k, False: 0]
  ------------------
  143|  4.89k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.89k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.89k|            }
  146|  4.89k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.89k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.89k|            }
  149|  4.89k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.89k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.89k|            }
  152|  4.89k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.89k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.89k|            }
  155|  4.89k|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.89k, False: 0]
  ------------------
  157|  4.89k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.89k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.89k|#if defined( __cpp_exceptions )
   74|  4.89k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.89k|            try {
   76|  4.89k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.89k|            }
   78|  4.89k|            catch( ... ) {
   79|  4.89k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.89k|               throw;
   81|  4.89k|            }
   82|  4.89k|         }
   83|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.89k|      {
   44|  4.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.89k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  143|  4.89k|            if constexpr( has_apply_void ) {
  144|  4.89k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.89k|            }
  146|  4.89k|            else if constexpr( has_apply_bool ) {
  147|  4.89k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.89k|            }
  149|  4.89k|            else if constexpr( has_apply0_void ) {
  150|  4.89k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.89k|            }
  152|  4.89k|            else if constexpr( has_apply0_bool ) {
  153|  4.89k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.89k|            }
  155|  4.89k|         }
  156|  4.89k|         if( result ) {
  157|  4.89k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.89k|         }
  159|  4.89k|         else {
  160|  4.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.89k|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.89k|      {
   44|  4.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.37k, False: 2.52k]
  ------------------
  143|  2.37k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.37k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.37k|            }
  146|  2.37k|            else if constexpr( has_apply_bool ) {
  147|  2.37k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.37k|            }
  149|  2.37k|            else if constexpr( has_apply0_void ) {
  150|  2.37k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.37k|            }
  152|  2.37k|            else if constexpr( has_apply0_bool ) {
  153|  2.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.37k|            }
  155|  2.37k|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.37k, False: 2.52k]
  ------------------
  157|  2.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.37k|         }
  159|  2.52k|         else {
  160|  2.52k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.52k|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.89k|#if defined( __cpp_exceptions )
   74|  4.89k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.89k|            try {
   76|  4.89k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.89k|            }
   78|  4.89k|            catch( ... ) {
   79|  4.89k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.89k|               throw;
   81|  4.89k|            }
   82|  4.89k|         }
   83|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.89k|      {
   44|  4.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 721, False: 4.17k]
  ------------------
  143|    721|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    721|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    721|            }
  146|    721|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    721|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    721|            }
  149|    721|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    721|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    721|            }
  152|    721|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    721|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    721|            }
  155|    721|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 721, False: 4.17k]
  ------------------
  157|    721|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    721|         }
  159|  4.17k|         else {
  160|  4.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.17k|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.89k|#if defined( __cpp_exceptions )
   74|  4.89k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.89k|            try {
   76|  4.89k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.89k|            }
   78|  4.89k|            catch( ... ) {
   79|  4.89k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.89k|               throw;
   81|  4.89k|            }
   82|  4.89k|         }
   83|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.89k|      {
   59|  4.89k|         return Rule::match( in );
   60|  4.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.17k|   {
  104|  4.17k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.17k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.17k|      }
  107|  4.17k|      else {
  108|  4.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.17k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.17k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.17k|         }
  128|       |
  129|  4.17k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.17k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.17k|         }
  132|       |
  133|  4.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 252, False: 3.92k]
  ------------------
  143|    252|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    252|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    252|            }
  146|    252|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    252|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    252|            }
  149|    252|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    252|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    252|            }
  152|    252|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    252|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    252|            }
  155|    252|         }
  156|  4.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 252, False: 3.92k]
  ------------------
  157|    252|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    252|         }
  159|  3.92k|         else {
  160|  3.92k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.92k|         }
  162|  4.17k|         (void)m( result );
  163|  4.17k|         return result;
  164|  4.17k|      }
  165|  4.17k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.17k|      {
   73|  4.17k|#if defined( __cpp_exceptions )
   74|  4.17k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.17k|            try {
   76|  4.17k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.17k|            }
   78|  4.17k|            catch( ... ) {
   79|  4.17k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.17k|               throw;
   81|  4.17k|            }
   82|  4.17k|         }
   83|  4.17k|         else {
   84|  4.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.17k|      {
   59|  4.17k|         return Rule::match( in );
   60|  4.17k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.92k|   {
  104|  3.92k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.92k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.92k|      }
  107|  3.92k|      else {
  108|  3.92k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.92k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.92k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.92k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.92k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.92k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.92k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.92k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.92k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.92k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.92k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.92k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.92k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.92k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.92k|         }
  128|       |
  129|  3.92k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.92k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.92k|         }
  132|       |
  133|  3.92k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.92k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.92k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.92k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.92k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.92k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.92k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.92k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 201, False: 3.72k]
  ------------------
  143|    201|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    201|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    201|            }
  146|    201|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    201|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    201|            }
  149|    201|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    201|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    201|            }
  152|    201|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    201|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    201|            }
  155|    201|         }
  156|  3.92k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 201, False: 3.72k]
  ------------------
  157|    201|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    201|         }
  159|  3.72k|         else {
  160|  3.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.72k|         }
  162|  3.92k|         (void)m( result );
  163|  3.92k|         return result;
  164|  3.92k|      }
  165|  3.92k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.92k|      {
   73|  3.92k|#if defined( __cpp_exceptions )
   74|  3.92k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.92k|            try {
   76|  3.92k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.92k|            }
   78|  3.92k|            catch( ... ) {
   79|  3.92k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.92k|               throw;
   81|  3.92k|            }
   82|  3.92k|         }
   83|  3.92k|         else {
   84|  3.92k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.92k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.92k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.92k|      {
   59|  3.92k|         return Rule::match( in );
   60|  3.92k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.72k|   {
  104|  3.72k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.72k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.72k|      }
  107|  3.72k|      else {
  108|  3.72k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.72k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.72k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.72k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.72k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.72k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.72k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.72k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.72k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.72k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.72k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.72k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.72k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.72k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.72k|         }
  128|       |
  129|  3.72k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.72k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.72k|         }
  132|       |
  133|  3.72k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.72k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.72k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.72k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.72k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.72k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.72k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.72k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 551, False: 3.17k]
  ------------------
  143|    551|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    551|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    551|            }
  146|    551|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    551|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    551|            }
  149|    551|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    551|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    551|            }
  152|    551|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    551|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    551|            }
  155|    551|         }
  156|  3.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 551, False: 3.17k]
  ------------------
  157|    551|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    551|         }
  159|  3.17k|         else {
  160|  3.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.17k|         }
  162|  3.72k|         (void)m( result );
  163|  3.72k|         return result;
  164|  3.72k|      }
  165|  3.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.72k|      {
   73|  3.72k|#if defined( __cpp_exceptions )
   74|  3.72k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.72k|            try {
   76|  3.72k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.72k|            }
   78|  3.72k|            catch( ... ) {
   79|  3.72k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.72k|               throw;
   81|  3.72k|            }
   82|  3.72k|         }
   83|  3.72k|         else {
   84|  3.72k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.72k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.72k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.72k|      {
   59|  3.72k|         return Rule::match( in );
   60|  3.72k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.17k|   {
  104|  3.17k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.17k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.17k|      }
  107|  3.17k|      else {
  108|  3.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.17k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.17k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.17k|         }
  128|       |
  129|  3.17k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.17k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.17k|         }
  132|       |
  133|  3.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 450, False: 2.72k]
  ------------------
  143|    450|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    450|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    450|            }
  146|    450|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    450|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    450|            }
  149|    450|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    450|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    450|            }
  152|    450|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    450|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    450|            }
  155|    450|         }
  156|  3.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 450, False: 2.72k]
  ------------------
  157|    450|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    450|         }
  159|  2.72k|         else {
  160|  2.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.72k|         }
  162|  3.17k|         (void)m( result );
  163|  3.17k|         return result;
  164|  3.17k|      }
  165|  3.17k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.17k|      {
   73|  3.17k|#if defined( __cpp_exceptions )
   74|  3.17k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.17k|            try {
   76|  3.17k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.17k|            }
   78|  3.17k|            catch( ... ) {
   79|  3.17k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.17k|               throw;
   81|  3.17k|            }
   82|  3.17k|         }
   83|  3.17k|         else {
   84|  3.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.17k|      {
   59|  3.17k|         return Rule::match( in );
   60|  3.17k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.72k|   {
  104|  2.72k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.72k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.72k|      }
  107|  2.72k|      else {
  108|  2.72k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.72k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.72k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.72k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.72k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.72k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.72k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.72k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.72k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.72k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.72k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.72k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.72k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.72k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.72k|         }
  128|       |
  129|  2.72k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.72k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.72k|         }
  132|       |
  133|  2.72k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.72k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.72k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.72k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.72k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.72k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.72k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.72k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 2.52k]
  ------------------
  143|    196|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    196|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    196|            }
  146|    196|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    196|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    196|            }
  149|    196|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    196|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    196|            }
  152|    196|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    196|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    196|            }
  155|    196|         }
  156|  2.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 2.52k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  2.52k|         else {
  160|  2.52k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.52k|         }
  162|  2.72k|         (void)m( result );
  163|  2.72k|         return result;
  164|  2.72k|      }
  165|  2.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.72k|      {
   73|  2.72k|#if defined( __cpp_exceptions )
   74|  2.72k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.72k|            try {
   76|  2.72k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.72k|            }
   78|  2.72k|            catch( ... ) {
   79|  2.72k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.72k|               throw;
   81|  2.72k|            }
   82|  2.72k|         }
   83|  2.72k|         else {
   84|  2.72k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.72k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.72k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.72k|      {
   59|  2.72k|         return Rule::match( in );
   60|  2.72k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|  4.89k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.89k|      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.89k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.89k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.89k|         }
  128|       |
  129|  4.89k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.89k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.89k|         }
  132|       |
  133|  4.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.32k, False: 1.56k]
  ------------------
  143|  3.32k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.32k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.32k|            }
  146|  3.32k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.32k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.32k|            }
  149|  3.32k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.32k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.32k|            }
  152|  3.32k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.32k|            }
  155|  3.32k|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.32k, False: 1.56k]
  ------------------
  157|  3.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.32k|         }
  159|  1.56k|         else {
  160|  1.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.56k|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.89k|#if defined( __cpp_exceptions )
   74|  4.89k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.89k|            try {
   76|  4.89k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.89k|            }
   78|  4.89k|            catch( ... ) {
   79|  4.89k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.89k|               throw;
   81|  4.89k|            }
   82|  4.89k|         }
   83|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.89k|      {
   59|  4.89k|         return Rule::match( in );
   60|  4.89k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.59k|   {
  104|  6.59k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.59k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.59k|      }
  107|  6.59k|      else {
  108|  6.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.59k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.59k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.59k|         }
  128|       |
  129|  6.59k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.59k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.59k|         }
  132|       |
  133|  6.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.59k, False: 0]
  ------------------
  143|  6.59k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.59k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.59k|            }
  146|  6.59k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.59k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.59k|            }
  149|  6.59k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.59k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.59k|            }
  152|  6.59k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.59k|            }
  155|  6.59k|         }
  156|  6.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.59k, False: 0]
  ------------------
  157|  6.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.59k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.59k|         (void)m( result );
  163|  6.59k|         return result;
  164|  6.59k|      }
  165|  6.59k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  6.59k|      {
   73|  6.59k|#if defined( __cpp_exceptions )
   74|  6.59k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.59k|            try {
   76|  6.59k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.59k|            }
   78|  6.59k|            catch( ... ) {
   79|  6.59k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.59k|               throw;
   81|  6.59k|            }
   82|  6.59k|         }
   83|  6.59k|         else {
   84|  6.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.59k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.59k|      {
   44|  6.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.59k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.32k|   {
  104|  3.32k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.32k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.32k|      }
  107|  3.32k|      else {
  108|  3.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.32k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.32k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.32k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.32k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.32k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.32k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.32k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.32k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.32k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.32k|         }
  128|       |
  129|  3.32k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.32k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.32k|         }
  132|       |
  133|  3.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.32k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.26k, False: 65]
  ------------------
  143|  3.26k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.26k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.26k|            }
  146|  3.26k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.26k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.26k|            }
  149|  3.26k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.26k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.26k|            }
  152|  3.26k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.26k|            }
  155|  3.26k|         }
  156|  3.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.26k, False: 65]
  ------------------
  157|  3.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.26k|         }
  159|     65|         else {
  160|     65|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     65|         }
  162|  3.32k|         (void)m( result );
  163|  3.32k|         return result;
  164|  3.32k|      }
  165|  3.32k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.32k|      {
   73|  3.32k|#if defined( __cpp_exceptions )
   74|  3.32k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.32k|            try {
   76|  3.32k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.32k|            }
   78|  3.32k|            catch( ... ) {
   79|  3.32k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.32k|               throw;
   81|  3.32k|            }
   82|  3.32k|         }
   83|  3.32k|         else {
   84|  3.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.32k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.32k|      {
   44|  3.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.32k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.27k|   {
  104|  3.27k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.27k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.27k|      }
  107|  3.27k|      else {
  108|  3.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.27k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.27k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.27k|         }
  128|       |
  129|  3.27k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.27k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.27k|         }
  132|       |
  133|  3.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.27k|         if( result ) {
  143|  3.27k|            if constexpr( has_apply_void ) {
  144|  3.27k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.27k|            }
  146|  3.27k|            else if constexpr( has_apply_bool ) {
  147|  3.27k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.27k|            }
  149|  3.27k|            else if constexpr( has_apply0_void ) {
  150|  3.27k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.27k|            }
  152|  3.27k|            else if constexpr( has_apply0_bool ) {
  153|  3.27k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.27k|            }
  155|  3.27k|         }
  156|  3.27k|         if( result ) {
  157|  3.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.27k|         }
  159|  3.27k|         else {
  160|  3.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.27k|         }
  162|  3.27k|         (void)m( result );
  163|  3.27k|         return result;
  164|  3.27k|      }
  165|  3.27k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.27k|      {
   44|  3.27k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.27k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   481k|   {
  104|   481k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   481k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   481k|      }
  107|   481k|      else {
  108|   481k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   481k|         using iterator_t = typename ParseInput::iterator_t;
  111|   481k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   481k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   481k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   481k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   481k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   481k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   481k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   481k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   481k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   481k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   481k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   481k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   481k|         }
  128|       |
  129|   481k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   481k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   481k|         }
  132|       |
  133|   481k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   481k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   481k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   481k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   481k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   481k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   481k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   481k|         if( result ) {
  143|   481k|            if constexpr( has_apply_void ) {
  144|   481k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   481k|            }
  146|   481k|            else if constexpr( has_apply_bool ) {
  147|   481k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   481k|            }
  149|   481k|            else if constexpr( has_apply0_void ) {
  150|   481k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   481k|            }
  152|   481k|            else if constexpr( has_apply0_bool ) {
  153|   481k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   481k|            }
  155|   481k|         }
  156|   481k|         if( result ) {
  157|   481k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   481k|         }
  159|   481k|         else {
  160|   481k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   481k|         }
  162|   481k|         (void)m( result );
  163|   481k|         return result;
  164|   481k|      }
  165|   481k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   481k|      {
   44|   481k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   481k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.26k|   {
  104|  3.26k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.26k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.26k|      }
  107|  3.26k|      else {
  108|  3.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.26k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.26k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.26k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.26k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.26k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.26k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.26k|         }
  128|       |
  129|  3.26k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.26k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.26k|         }
  132|       |
  133|  3.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.13k, False: 128]
  ------------------
  143|  3.13k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.13k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.13k|            }
  146|  3.13k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.13k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.13k|            }
  149|  3.13k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.13k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.13k|            }
  152|  3.13k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.13k|            }
  155|  3.13k|         }
  156|  3.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.13k, False: 128]
  ------------------
  157|  3.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.13k|         }
  159|    128|         else {
  160|    128|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    128|         }
  162|  3.26k|         (void)m( result );
  163|  3.26k|         return result;
  164|  3.26k|      }
  165|  3.26k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.26k|      {
   73|  3.26k|#if defined( __cpp_exceptions )
   74|  3.26k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.26k|            try {
   76|  3.26k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.26k|            }
   78|  3.26k|            catch( ... ) {
   79|  3.26k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.26k|               throw;
   81|  3.26k|            }
   82|  3.26k|         }
   83|  3.26k|         else {
   84|  3.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.26k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.26k|      {
   59|  3.26k|         return Rule::match( in );
   60|  3.26k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   484k|   {
  104|   484k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   484k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   484k|      }
  107|   484k|      else {
  108|   484k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   484k|         using iterator_t = typename ParseInput::iterator_t;
  111|   484k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   484k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   484k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   484k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   484k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   484k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   484k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   484k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   484k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   484k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   484k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   484k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   484k|         }
  128|       |
  129|   484k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   484k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   484k|         }
  132|       |
  133|   484k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   484k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   484k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   484k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   484k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   484k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   484k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   484k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 482k, False: 1.69k]
  ------------------
  143|   482k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   482k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   482k|            }
  146|   482k|            else if constexpr( has_apply_bool ) {
  147|   482k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   482k|            }
  149|   482k|            else if constexpr( has_apply0_void ) {
  150|   482k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   482k|            }
  152|   482k|            else if constexpr( has_apply0_bool ) {
  153|   482k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   482k|            }
  155|   482k|         }
  156|   484k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 482k, False: 1.76k]
  ------------------
  157|   482k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   482k|         }
  159|  1.76k|         else {
  160|  1.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.76k|         }
  162|   484k|         (void)m( result );
  163|   484k|         return result;
  164|   484k|      }
  165|   484k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   484k|      {
   73|   484k|#if defined( __cpp_exceptions )
   74|   484k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   484k|            try {
   76|   484k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   484k|            }
   78|   484k|            catch( ... ) {
   79|   484k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   484k|               throw;
   81|   484k|            }
   82|   484k|         }
   83|   484k|         else {
   84|   484k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   484k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   484k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   484k|      {
   44|   484k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   484k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   484k|   {
  104|   484k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   484k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   484k|      }
  107|   484k|      else {
  108|   484k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   484k|         using iterator_t = typename ParseInput::iterator_t;
  111|   484k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   484k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   484k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   484k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   484k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   484k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   484k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   484k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   484k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   484k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   484k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   484k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   484k|         }
  128|       |
  129|   484k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   484k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   484k|         }
  132|       |
  133|   484k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   484k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   484k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   484k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   484k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   484k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   484k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   484k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 482k, False: 1.38k]
  ------------------
  143|   482k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   482k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   482k|            }
  146|   482k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   482k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   482k|            }
  149|   482k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   482k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   482k|            }
  152|   482k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   482k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   482k|            }
  155|   482k|         }
  156|   484k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 482k, False: 1.38k]
  ------------------
  157|   482k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   482k|         }
  159|  1.38k|         else {
  160|  1.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.38k|         }
  162|   484k|         (void)m( result );
  163|   484k|         return result;
  164|   484k|      }
  165|   484k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   484k|      {
   73|   484k|#if defined( __cpp_exceptions )
   74|   484k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   484k|            try {
   76|   484k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   484k|            }
   78|   484k|            catch( ... ) {
   79|   484k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   484k|               throw;
   81|   484k|            }
   82|   484k|         }
   83|   484k|         else {
   84|   484k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   484k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   484k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   484k|      {
   59|   484k|         return Rule::match( in );
   60|   484k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   482k|   {
  104|   482k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   482k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   482k|      }
  107|   482k|      else {
  108|   482k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   482k|         using iterator_t = typename ParseInput::iterator_t;
  111|   482k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   482k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   482k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   482k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   482k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   482k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   482k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   482k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   482k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   482k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   482k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   482k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   482k|         }
  128|       |
  129|   482k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   482k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   482k|         }
  132|       |
  133|   482k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   482k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   482k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   482k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   482k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   482k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   482k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   482k|         if( result ) {
  143|   482k|            if constexpr( has_apply_void ) {
  144|   482k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   482k|            }
  146|   482k|            else if constexpr( has_apply_bool ) {
  147|   482k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   482k|            }
  149|   482k|            else if constexpr( has_apply0_void ) {
  150|   482k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   482k|            }
  152|   482k|            else if constexpr( has_apply0_bool ) {
  153|   482k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   482k|            }
  155|   482k|         }
  156|   482k|         if( result ) {
  157|   482k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   482k|         }
  159|   482k|         else {
  160|   482k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   482k|         }
  162|   482k|         (void)m( result );
  163|   482k|         return result;
  164|   482k|      }
  165|   482k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   482k|      {
   44|   482k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   482k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   482k|   {
  104|   482k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   482k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   482k|      }
  107|   482k|      else {
  108|   482k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   482k|         using iterator_t = typename ParseInput::iterator_t;
  111|   482k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   482k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   482k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   482k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   482k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   482k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   482k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   482k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   482k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   482k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   482k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   482k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   482k|         }
  128|       |
  129|   482k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   482k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   482k|         }
  132|       |
  133|   482k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   482k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   482k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   482k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   482k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   482k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   482k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   482k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 482k, False: 311]
  ------------------
  143|   482k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   482k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   482k|            }
  146|   482k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   482k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   482k|            }
  149|   482k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   482k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   482k|            }
  152|   482k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   482k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   482k|            }
  155|   482k|         }
  156|   482k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 482k, False: 311]
  ------------------
  157|   482k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   482k|         }
  159|    311|         else {
  160|    311|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    311|         }
  162|   482k|         (void)m( result );
  163|   482k|         return result;
  164|   482k|      }
  165|   482k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   482k|      {
   73|   482k|#if defined( __cpp_exceptions )
   74|   482k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   482k|            try {
   76|   482k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   482k|            }
   78|   482k|            catch( ... ) {
   79|   482k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   482k|               throw;
   81|   482k|            }
   82|   482k|         }
   83|   482k|         else {
   84|   482k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   482k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   482k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   482k|      {
   44|   482k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   482k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.60M|   {
  104|  9.60M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.60M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.60M|      }
  107|  9.60M|      else {
  108|  9.60M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.60M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.60M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.60M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.60M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.60M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.60M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.60M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.60M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.60M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.60M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.60M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.60M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.60M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.60M|         }
  128|       |
  129|  9.60M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.60M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.60M|         }
  132|       |
  133|  9.60M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.60M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.60M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.60M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.60M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.60M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.60M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.60M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 482k, False: 9.12M]
  ------------------
  143|   482k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   482k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   482k|            }
  146|   482k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   482k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   482k|            }
  149|   482k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   482k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   482k|            }
  152|   482k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   482k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   482k|            }
  155|   482k|         }
  156|  9.60M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 482k, False: 9.12M]
  ------------------
  157|   482k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   482k|         }
  159|  9.12M|         else {
  160|  9.12M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.12M|         }
  162|  9.60M|         (void)m( result );
  163|  9.60M|         return result;
  164|  9.60M|      }
  165|  9.60M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.60M|      {
   73|  9.60M|#if defined( __cpp_exceptions )
   74|  9.60M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.60M|            try {
   76|  9.60M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.60M|            }
   78|  9.60M|            catch( ... ) {
   79|  9.60M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.60M|               throw;
   81|  9.60M|            }
   82|  9.60M|         }
   83|  9.60M|         else {
   84|  9.60M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.60M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.60M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.60M|      {
   59|  9.60M|         return Rule::match( in );
   60|  9.60M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.12M|   {
  104|  9.12M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.12M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.12M|      }
  107|  9.12M|      else {
  108|  9.12M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.12M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.12M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.12M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.12M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.12M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.12M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.12M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.12M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.12M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.12M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.12M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.12M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.12M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.12M|         }
  128|       |
  129|  9.12M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.12M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.12M|         }
  132|       |
  133|  9.12M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.12M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.12M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.12M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.12M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.12M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.12M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.12M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.12M, False: 311]
  ------------------
  143|  9.12M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.12M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.12M|            }
  146|  9.12M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  9.12M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.12M|            }
  149|  9.12M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  9.12M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.12M|            }
  152|  9.12M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  9.12M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.12M|            }
  155|  9.12M|         }
  156|  9.12M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.12M, False: 311]
  ------------------
  157|  9.12M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.12M|         }
  159|    311|         else {
  160|    311|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    311|         }
  162|  9.12M|         (void)m( result );
  163|  9.12M|         return result;
  164|  9.12M|      }
  165|  9.12M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.12M|      {
   73|  9.12M|#if defined( __cpp_exceptions )
   74|  9.12M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.12M|            try {
   76|  9.12M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.12M|            }
   78|  9.12M|            catch( ... ) {
   79|  9.12M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.12M|               throw;
   81|  9.12M|            }
   82|  9.12M|         }
   83|  9.12M|         else {
   84|  9.12M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.12M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.12M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.12M|      {
   44|  9.12M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.12M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.12M|   {
  104|  9.12M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.12M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.12M|      }
  107|  9.12M|      else {
  108|  9.12M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.12M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.12M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.12M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.12M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.12M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.12M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.12M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.12M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.12M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.12M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.12M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.12M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.12M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.12M|         }
  128|       |
  129|  9.12M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.12M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.12M|         }
  132|       |
  133|  9.12M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.12M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.12M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.12M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.12M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.12M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.12M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.12M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 165k, False: 8.95M]
  ------------------
  143|   165k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   165k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   165k|            }
  146|   165k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   165k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   165k|            }
  149|   165k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   165k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   165k|            }
  152|   165k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   165k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   165k|            }
  155|   165k|         }
  156|  9.12M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 165k, False: 8.95M]
  ------------------
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|  8.95M|         else {
  160|  8.95M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.95M|         }
  162|  9.12M|         (void)m( result );
  163|  9.12M|         return result;
  164|  9.12M|      }
  165|  9.12M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.12M|      {
   73|  9.12M|#if defined( __cpp_exceptions )
   74|  9.12M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.12M|            try {
   76|  9.12M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.12M|            }
   78|  9.12M|            catch( ... ) {
   79|  9.12M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.12M|               throw;
   81|  9.12M|            }
   82|  9.12M|         }
   83|  9.12M|         else {
   84|  9.12M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.12M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.12M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.12M|      {
   44|  9.12M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.12M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.12M|   {
  104|  9.12M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.12M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.12M|      }
  107|  9.12M|      else {
  108|  9.12M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.12M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.12M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.12M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.12M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.12M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.12M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.12M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.12M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.12M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.12M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.12M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.12M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.12M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.12M|         }
  128|       |
  129|  9.12M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.12M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.12M|         }
  132|       |
  133|  9.12M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.12M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.12M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.12M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.12M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.12M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.12M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.12M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 165k, False: 8.95M]
  ------------------
  143|   165k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   165k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   165k|            }
  146|   165k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   165k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   165k|            }
  149|   165k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   165k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   165k|            }
  152|   165k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   165k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   165k|            }
  155|   165k|         }
  156|  9.12M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 165k, False: 8.95M]
  ------------------
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|  8.95M|         else {
  160|  8.95M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.95M|         }
  162|  9.12M|         (void)m( result );
  163|  9.12M|         return result;
  164|  9.12M|      }
  165|  9.12M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.12M|      {
   73|  9.12M|#if defined( __cpp_exceptions )
   74|  9.12M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.12M|            try {
   76|  9.12M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.12M|            }
   78|  9.12M|            catch( ... ) {
   79|  9.12M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.12M|               throw;
   81|  9.12M|            }
   82|  9.12M|         }
   83|  9.12M|         else {
   84|  9.12M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.12M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.12M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.12M|      {
   59|  9.12M|         return Rule::match( in );
   60|  9.12M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|   165k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   165k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   165k|      }
  107|   165k|      else {
  108|   165k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   165k|         using iterator_t = typename ParseInput::iterator_t;
  111|   165k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   165k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   165k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   165k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   165k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   165k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   165k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   165k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   165k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   165k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   165k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   165k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   165k|         }
  128|       |
  129|   165k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   165k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   165k|         }
  132|       |
  133|   165k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   165k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   165k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   165k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   165k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   165k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   165k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   165k|         if( result ) {
  143|   165k|            if constexpr( has_apply_void ) {
  144|   165k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   165k|            }
  146|   165k|            else if constexpr( has_apply_bool ) {
  147|   165k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   165k|            }
  149|   165k|            else if constexpr( has_apply0_void ) {
  150|   165k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   165k|            }
  152|   165k|            else if constexpr( has_apply0_bool ) {
  153|   165k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   165k|            }
  155|   165k|         }
  156|   165k|         if( result ) {
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|   165k|         else {
  160|   165k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   165k|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   165k|      {
   44|   165k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   165k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|   165k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   165k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   165k|      }
  107|   165k|      else {
  108|   165k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   165k|         using iterator_t = typename ParseInput::iterator_t;
  111|   165k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   165k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   165k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   165k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   165k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   165k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   165k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   165k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   165k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   165k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   165k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   165k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   165k|         }
  128|       |
  129|   165k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   165k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   165k|         }
  132|       |
  133|   165k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   165k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   165k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   165k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   165k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   165k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   165k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   165k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 165k, False: 120]
  ------------------
  143|   165k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   165k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   165k|            }
  146|   165k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   165k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   165k|            }
  149|   165k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   165k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   165k|            }
  152|   165k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   165k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   165k|            }
  155|   165k|         }
  156|   165k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 165k, False: 120]
  ------------------
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|    120|         else {
  160|    120|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    120|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   165k|      {
   73|   165k|#if defined( __cpp_exceptions )
   74|   165k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   165k|            try {
   76|   165k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   165k|            }
   78|   165k|            catch( ... ) {
   79|   165k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   165k|               throw;
   81|   165k|            }
   82|   165k|         }
   83|   165k|         else {
   84|   165k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   165k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   165k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   165k|      {
   44|   165k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   165k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|   165k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   165k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   165k|      }
  107|   165k|      else {
  108|   165k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   165k|         using iterator_t = typename ParseInput::iterator_t;
  111|   165k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   165k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   165k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   165k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   165k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   165k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   165k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   165k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   165k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   165k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   165k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   165k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   165k|         }
  128|       |
  129|   165k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   165k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   165k|         }
  132|       |
  133|   165k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   165k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   165k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   165k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   165k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   165k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   165k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   165k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 47.8k, False: 118k]
  ------------------
  143|  47.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  47.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.8k|            }
  146|  47.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  47.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.8k|            }
  149|  47.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  47.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.8k|            }
  152|  47.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  47.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.8k|            }
  155|  47.8k|         }
  156|   165k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 47.8k, False: 118k]
  ------------------
  157|  47.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.8k|         }
  159|   118k|         else {
  160|   118k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   118k|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   165k|      {
   73|   165k|#if defined( __cpp_exceptions )
   74|   165k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   165k|            try {
   76|   165k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   165k|            }
   78|   165k|            catch( ... ) {
   79|   165k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   165k|               throw;
   81|   165k|            }
   82|   165k|         }
   83|   165k|         else {
   84|   165k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   165k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   165k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   165k|      {
   44|   165k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   165k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|   165k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   165k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   165k|      }
  107|   165k|      else {
  108|   165k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   165k|         using iterator_t = typename ParseInput::iterator_t;
  111|   165k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   165k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   165k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   165k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   165k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   165k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   165k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   165k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   165k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   165k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   165k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   165k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   165k|         }
  128|       |
  129|   165k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   165k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   165k|         }
  132|       |
  133|   165k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   165k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   165k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   165k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   165k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   165k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   165k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   165k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 47.9k, False: 117k]
  ------------------
  143|  47.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  47.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.9k|            }
  146|  47.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  47.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.9k|            }
  149|  47.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  47.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.9k|            }
  152|  47.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  47.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.9k|            }
  155|  47.9k|         }
  156|   165k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 47.9k, False: 117k]
  ------------------
  157|  47.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.9k|         }
  159|   117k|         else {
  160|   117k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   117k|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   165k|      {
   73|   165k|#if defined( __cpp_exceptions )
   74|   165k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   165k|            try {
   76|   165k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   165k|            }
   78|   165k|            catch( ... ) {
   79|   165k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   165k|               throw;
   81|   165k|            }
   82|   165k|         }
   83|   165k|         else {
   84|   165k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   165k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   165k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   165k|      {
   59|   165k|         return Rule::match( in );
   60|   165k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  47.9k|   {
  104|  47.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.9k|      }
  107|  47.9k|      else {
  108|  47.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  47.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  47.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  47.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  47.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  47.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  47.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  47.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.9k|         }
  128|       |
  129|  47.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  47.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.9k|         }
  132|       |
  133|  47.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  47.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.9k|         if( result ) {
  143|  47.9k|            if constexpr( has_apply_void ) {
  144|  47.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.9k|            }
  146|  47.9k|            else if constexpr( has_apply_bool ) {
  147|  47.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.9k|            }
  149|  47.9k|            else if constexpr( has_apply0_void ) {
  150|  47.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.9k|            }
  152|  47.9k|            else if constexpr( has_apply0_bool ) {
  153|  47.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.9k|            }
  155|  47.9k|         }
  156|  47.9k|         if( result ) {
  157|  47.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.9k|         }
  159|  47.9k|         else {
  160|  47.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.9k|         }
  162|  47.9k|         (void)m( result );
  163|  47.9k|         return result;
  164|  47.9k|      }
  165|  47.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.9k|      {
   44|  47.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.9k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  47.9k|   {
  104|  47.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.9k|      }
  107|  47.9k|      else {
  108|  47.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.9k|         }
  128|       |
  129|  47.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.9k|         }
  132|       |
  133|  47.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 47.8k, False: 52]
  ------------------
  143|  47.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  47.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.8k|            }
  146|  47.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  47.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.8k|            }
  149|  47.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  47.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.8k|            }
  152|  47.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  47.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.8k|            }
  155|  47.8k|         }
  156|  47.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 47.8k, False: 52]
  ------------------
  157|  47.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.8k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  47.9k|         (void)m( result );
  163|  47.9k|         return result;
  164|  47.9k|      }
  165|  47.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  47.9k|      {
   73|  47.9k|#if defined( __cpp_exceptions )
   74|  47.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.9k|            try {
   76|  47.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.9k|            }
   78|  47.9k|            catch( ... ) {
   79|  47.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.9k|               throw;
   81|  47.9k|            }
   82|  47.9k|         }
   83|  47.9k|         else {
   84|  47.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.9k|      {
   44|  47.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  95.8k|   {
  104|  95.8k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  95.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  95.8k|      }
  107|  95.8k|      else {
  108|  95.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  95.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  95.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  95.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  95.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  95.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  95.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  95.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  95.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  95.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  95.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  95.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  95.8k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  95.8k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  95.8k|         }
  128|       |
  129|  95.8k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  95.8k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  95.8k|         }
  132|       |
  133|  95.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  95.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  95.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  95.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  95.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  95.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  95.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  95.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 95.7k, False: 52]
  ------------------
  143|  95.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  95.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  95.7k|            }
  146|  95.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  95.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  95.7k|            }
  149|  95.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  95.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  95.7k|            }
  152|  95.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  95.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  95.7k|            }
  155|  95.7k|         }
  156|  95.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 95.7k, False: 52]
  ------------------
  157|  95.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  95.7k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  95.8k|         (void)m( result );
  163|  95.8k|         return result;
  164|  95.8k|      }
  165|  95.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  95.8k|      {
   73|  95.8k|#if defined( __cpp_exceptions )
   74|  95.8k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  95.8k|            try {
   76|  95.8k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  95.8k|            }
   78|  95.8k|            catch( ... ) {
   79|  95.8k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  95.8k|               throw;
   81|  95.8k|            }
   82|  95.8k|         }
   83|  95.8k|         else {
   84|  95.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  95.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  95.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  95.8k|      {
   59|  95.8k|         return Rule::match( in );
   60|  95.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   117k|   {
  104|   117k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   117k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   117k|      }
  107|   117k|      else {
  108|   117k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   117k|         using iterator_t = typename ParseInput::iterator_t;
  111|   117k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   117k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   117k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   117k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   117k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   117k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   117k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   117k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   117k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   117k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   117k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   117k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   117k|         }
  128|       |
  129|   117k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   117k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   117k|         }
  132|       |
  133|   117k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   117k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   117k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   117k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   117k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   117k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   117k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   117k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 50.4k, False: 67.5k]
  ------------------
  143|  50.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  50.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  50.4k|            }
  146|  50.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  50.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  50.4k|            }
  149|  50.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  50.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  50.4k|            }
  152|  50.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  50.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  50.4k|            }
  155|  50.4k|         }
  156|   117k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 50.4k, False: 67.5k]
  ------------------
  157|  50.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  50.4k|         }
  159|  67.5k|         else {
  160|  67.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.5k|         }
  162|   117k|         (void)m( result );
  163|   117k|         return result;
  164|   117k|      }
  165|   117k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   117k|      {
   73|   117k|#if defined( __cpp_exceptions )
   74|   117k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   117k|            try {
   76|   117k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   117k|            }
   78|   117k|            catch( ... ) {
   79|   117k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   117k|               throw;
   81|   117k|            }
   82|   117k|         }
   83|   117k|         else {
   84|   117k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   117k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   117k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   117k|      {
   44|   117k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   117k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   193k|   {
  104|   193k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   193k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   193k|      }
  107|   193k|      else {
  108|   193k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   193k|         using iterator_t = typename ParseInput::iterator_t;
  111|   193k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   193k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   193k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   193k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   193k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   193k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   193k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   193k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   193k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   193k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   193k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   193k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   193k|         }
  128|       |
  129|   193k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   193k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   193k|         }
  132|       |
  133|   193k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   193k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   193k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   193k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   193k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   193k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   193k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   193k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 86.6k, False: 107k]
  ------------------
  143|  86.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  86.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  86.6k|            }
  146|  86.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  86.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  86.6k|            }
  149|  86.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  86.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  86.6k|            }
  152|  86.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  86.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  86.6k|            }
  155|  86.6k|         }
  156|   193k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 86.6k, False: 107k]
  ------------------
  157|  86.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  86.6k|         }
  159|   107k|         else {
  160|   107k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   107k|         }
  162|   193k|         (void)m( result );
  163|   193k|         return result;
  164|   193k|      }
  165|   193k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   193k|      {
   73|   193k|#if defined( __cpp_exceptions )
   74|   193k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   193k|            try {
   76|   193k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   193k|            }
   78|   193k|            catch( ... ) {
   79|   193k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   193k|               throw;
   81|   193k|            }
   82|   193k|         }
   83|   193k|         else {
   84|   193k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   193k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   193k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   193k|      {
   59|   193k|         return Rule::match( in );
   60|   193k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  50.4k|   {
  104|  50.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  50.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  50.4k|      }
  107|  50.4k|      else {
  108|  50.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  50.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  50.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  50.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  50.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  50.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  50.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  50.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  50.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  50.4k|         }
  128|       |
  129|  50.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  50.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  50.4k|         }
  132|       |
  133|  50.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  50.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  50.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.4k|         if( result ) {
  143|  50.4k|            if constexpr( has_apply_void ) {
  144|  50.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  50.4k|            }
  146|  50.4k|            else if constexpr( has_apply_bool ) {
  147|  50.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  50.4k|            }
  149|  50.4k|            else if constexpr( has_apply0_void ) {
  150|  50.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  50.4k|            }
  152|  50.4k|            else if constexpr( has_apply0_bool ) {
  153|  50.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  50.4k|            }
  155|  50.4k|         }
  156|  50.4k|         if( result ) {
  157|  50.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  50.4k|         }
  159|  50.4k|         else {
  160|  50.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  50.4k|         }
  162|  50.4k|         (void)m( result );
  163|  50.4k|         return result;
  164|  50.4k|      }
  165|  50.4k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  50.4k|      {
   44|  50.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.4k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  50.4k|   {
  104|  50.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  50.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  50.4k|      }
  107|  50.4k|      else {
  108|  50.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  50.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  50.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  50.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  50.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  50.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  50.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  50.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  50.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  50.4k|         }
  128|       |
  129|  50.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  50.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  50.4k|         }
  132|       |
  133|  50.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  50.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  50.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 50.4k, False: 0]
  ------------------
  143|  50.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  50.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  50.4k|            }
  146|  50.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  50.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  50.4k|            }
  149|  50.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  50.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  50.4k|            }
  152|  50.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  50.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  50.4k|            }
  155|  50.4k|         }
  156|  50.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 50.4k, False: 0]
  ------------------
  157|  50.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  50.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  50.4k|         (void)m( result );
  163|  50.4k|         return result;
  164|  50.4k|      }
  165|  50.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  50.4k|      {
   73|  50.4k|#if defined( __cpp_exceptions )
   74|  50.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  50.4k|            try {
   76|  50.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  50.4k|            }
   78|  50.4k|            catch( ... ) {
   79|  50.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  50.4k|               throw;
   81|  50.4k|            }
   82|  50.4k|         }
   83|  50.4k|         else {
   84|  50.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  50.4k|      {
   44|  50.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  67.5k|   {
  104|  67.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  67.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  67.5k|      }
  107|  67.5k|      else {
  108|  67.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  67.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  67.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  67.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  67.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  67.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  67.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  67.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  67.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  67.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  67.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  67.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  67.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  67.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  67.5k|         }
  128|       |
  129|  67.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  67.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  67.5k|         }
  132|       |
  133|  67.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  67.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  67.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  67.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  67.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  67.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  67.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  67.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 66.7k, False: 751]
  ------------------
  143|  66.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  66.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  66.7k|            }
  146|  66.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  66.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  66.7k|            }
  149|  66.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  66.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  66.7k|            }
  152|  66.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  66.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  66.7k|            }
  155|  66.7k|         }
  156|  67.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 66.7k, False: 751]
  ------------------
  157|  66.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  66.7k|         }
  159|    751|         else {
  160|    751|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    751|         }
  162|  67.5k|         (void)m( result );
  163|  67.5k|         return result;
  164|  67.5k|      }
  165|  67.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  67.5k|      {
   73|  67.5k|#if defined( __cpp_exceptions )
   74|  67.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  67.5k|            try {
   76|  67.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  67.5k|            }
   78|  67.5k|            catch( ... ) {
   79|  67.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  67.5k|               throw;
   81|  67.5k|            }
   82|  67.5k|         }
   83|  67.5k|         else {
   84|  67.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  67.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  67.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  67.5k|      {
   59|  67.5k|         return Rule::match( in );
   60|  67.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    751|   {
  104|    751|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|    751|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|    751|      }
  107|    751|      else {
  108|    751|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    751|         using iterator_t = typename ParseInput::iterator_t;
  111|    751|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|    751|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|    751|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|    751|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|    751|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|    751|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|    751|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    751|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    751|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    751|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|    751|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|    751|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|    751|         }
  128|       |
  129|    751|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|    751|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|    751|         }
  132|       |
  133|    751|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    751|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    751|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    751|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|    751|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    751|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    751|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    751|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 683, False: 68]
  ------------------
  143|    683|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    683|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    683|            }
  146|    683|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    683|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    683|            }
  149|    683|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    683|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    683|            }
  152|    683|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    683|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    683|            }
  155|    683|         }
  156|    751|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 683, False: 68]
  ------------------
  157|    683|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    683|         }
  159|     68|         else {
  160|     68|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     68|         }
  162|    751|         (void)m( result );
  163|    751|         return result;
  164|    751|      }
  165|    751|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    751|      {
   73|    751|#if defined( __cpp_exceptions )
   74|    751|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|    751|            try {
   76|    751|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|    751|            }
   78|    751|            catch( ... ) {
   79|    751|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|    751|               throw;
   81|    751|            }
   82|    751|         }
   83|    751|         else {
   84|    751|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    751|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    751|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    751|      {
   59|    751|         return Rule::match( in );
   60|    751|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.95M|   {
  104|  8.95M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  8.95M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  8.95M|      }
  107|  8.95M|      else {
  108|  8.95M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.95M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.95M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  8.95M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  8.95M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  8.95M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  8.95M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  8.95M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  8.95M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.95M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.95M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.95M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  8.95M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  8.95M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  8.95M|         }
  128|       |
  129|  8.95M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  8.95M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  8.95M|         }
  132|       |
  133|  8.95M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.95M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.95M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.95M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  8.95M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.95M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.95M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.95M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.95M, False: 191]
  ------------------
  143|  8.95M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  8.95M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  8.95M|            }
  146|  8.95M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  8.95M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  8.95M|            }
  149|  8.95M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  8.95M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  8.95M|            }
  152|  8.95M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  8.95M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.95M|            }
  155|  8.95M|         }
  156|  8.95M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.95M, False: 191]
  ------------------
  157|  8.95M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.95M|         }
  159|    191|         else {
  160|    191|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    191|         }
  162|  8.95M|         (void)m( result );
  163|  8.95M|         return result;
  164|  8.95M|      }
  165|  8.95M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.95M|      {
   73|  8.95M|#if defined( __cpp_exceptions )
   74|  8.95M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  8.95M|            try {
   76|  8.95M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  8.95M|            }
   78|  8.95M|            catch( ... ) {
   79|  8.95M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  8.95M|               throw;
   81|  8.95M|            }
   82|  8.95M|         }
   83|  8.95M|         else {
   84|  8.95M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.95M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.95M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.95M|      {
   59|  8.95M|         return Rule::match( in );
   60|  8.95M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.1k|   {
  104|  37.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  37.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  37.1k|      }
  107|  37.1k|      else {
  108|  37.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  37.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  37.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  37.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  37.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  37.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  37.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  37.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  37.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  37.1k|         }
  128|       |
  129|  37.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  37.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  37.1k|         }
  132|       |
  133|  37.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  37.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.83k, False: 33.3k]
  ------------------
  143|  3.83k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.83k|            }
  146|  3.83k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.83k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.83k|            }
  149|  3.83k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.83k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.83k|            }
  152|  3.83k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.83k|            }
  155|  3.83k|         }
  156|  37.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.83k, False: 33.3k]
  ------------------
  157|  3.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.83k|         }
  159|  33.3k|         else {
  160|  33.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.3k|         }
  162|  37.1k|         (void)m( result );
  163|  37.1k|         return result;
  164|  37.1k|      }
  165|  37.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  37.1k|      {
   73|  37.1k|#if defined( __cpp_exceptions )
   74|  37.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  37.1k|            try {
   76|  37.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  37.1k|            }
   78|  37.1k|            catch( ... ) {
   79|  37.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  37.1k|               throw;
   81|  37.1k|            }
   82|  37.1k|         }
   83|  37.1k|         else {
   84|  37.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  37.1k|      {
   44|  37.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.1k|   {
  104|  37.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  37.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  37.1k|      }
  107|  37.1k|      else {
  108|  37.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  37.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  37.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  37.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  37.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  37.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  37.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  37.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  37.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  37.1k|         }
  128|       |
  129|  37.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  37.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  37.1k|         }
  132|       |
  133|  37.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  37.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.83k, False: 33.3k]
  ------------------
  143|  3.83k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.83k|            }
  146|  3.83k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.83k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.83k|            }
  149|  3.83k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.83k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.83k|            }
  152|  3.83k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.83k|            }
  155|  3.83k|         }
  156|  37.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.83k, False: 33.3k]
  ------------------
  157|  3.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.83k|         }
  159|  33.3k|         else {
  160|  33.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.3k|         }
  162|  37.1k|         (void)m( result );
  163|  37.1k|         return result;
  164|  37.1k|      }
  165|  37.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_8str_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  37.1k|      {
   73|  37.1k|#if defined( __cpp_exceptions )
   74|  37.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  37.1k|            try {
   76|  37.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  37.1k|            }
   78|  37.1k|            catch( ... ) {
   79|  37.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  37.1k|               throw;
   81|  37.1k|            }
   82|  37.1k|         }
   83|  37.1k|         else {
   84|  37.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_8str_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  37.1k|      {
   44|  37.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.1k|   {
  104|  37.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  37.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  37.1k|      }
  107|  37.1k|      else {
  108|  37.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  37.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  37.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  37.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  37.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  37.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  37.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  37.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  37.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  37.1k|         }
  128|       |
  129|  37.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  37.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  37.1k|         }
  132|       |
  133|  37.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  37.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.55k, False: 32.6k]
  ------------------
  143|  4.55k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.55k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.55k|            }
  146|  4.55k|            else if constexpr( has_apply_bool ) {
  147|  4.55k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.55k|            }
  149|  4.55k|            else if constexpr( has_apply0_void ) {
  150|  4.55k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.55k|            }
  152|  4.55k|            else if constexpr( has_apply0_bool ) {
  153|  4.55k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.55k|            }
  155|  4.55k|         }
  156|  37.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.55k, False: 32.6k]
  ------------------
  157|  4.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.55k|         }
  159|  32.6k|         else {
  160|  32.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.6k|         }
  162|  37.1k|         (void)m( result );
  163|  37.1k|         return result;
  164|  37.1k|      }
  165|  37.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  37.1k|      {
   73|  37.1k|#if defined( __cpp_exceptions )
   74|  37.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  37.1k|            try {
   76|  37.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  37.1k|            }
   78|  37.1k|            catch( ... ) {
   79|  37.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  37.1k|               throw;
   81|  37.1k|            }
   82|  37.1k|         }
   83|  37.1k|         else {
   84|  37.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  37.1k|      {
   59|  37.1k|         return Rule::match( in );
   60|  37.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6k|   {
  104|  15.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  15.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  15.6k|      }
  107|  15.6k|      else {
  108|  15.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  15.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  15.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  15.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  15.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  15.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  15.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  15.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  15.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  15.6k|         }
  128|       |
  129|  15.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  15.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  15.6k|         }
  132|       |
  133|  15.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  15.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  15.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 12.9k, False: 2.64k]
  ------------------
  143|  12.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  12.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  12.9k|            }
  146|  12.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  12.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  12.9k|            }
  149|  12.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  12.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  12.9k|            }
  152|  12.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  12.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  12.9k|            }
  155|  12.9k|         }
  156|  15.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 12.9k, False: 2.64k]
  ------------------
  157|  12.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  12.9k|         }
  159|  2.64k|         else {
  160|  2.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.64k|         }
  162|  15.6k|         (void)m( result );
  163|  15.6k|         return result;
  164|  15.6k|      }
  165|  15.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  15.6k|      {
   73|  15.6k|#if defined( __cpp_exceptions )
   74|  15.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  15.6k|            try {
   76|  15.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  15.6k|            }
   78|  15.6k|            catch( ... ) {
   79|  15.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  15.6k|               throw;
   81|  15.6k|            }
   82|  15.6k|         }
   83|  15.6k|         else {
   84|  15.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  15.6k|      {
   44|  15.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  15.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6k|   {
  104|  15.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  15.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  15.6k|      }
  107|  15.6k|      else {
  108|  15.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  15.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  15.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  15.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  15.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  15.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  15.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  15.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  15.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  15.6k|         }
  128|       |
  129|  15.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  15.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  15.6k|         }
  132|       |
  133|  15.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  15.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  15.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 12.9k, False: 2.64k]
  ------------------
  143|  12.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  12.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  12.9k|            }
  146|  12.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  12.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  12.9k|            }
  149|  12.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  12.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  12.9k|            }
  152|  12.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  12.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  12.9k|            }
  155|  12.9k|         }
  156|  15.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 12.9k, False: 2.64k]
  ------------------
  157|  12.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  12.9k|         }
  159|  2.64k|         else {
  160|  2.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.64k|         }
  162|  15.6k|         (void)m( result );
  163|  15.6k|         return result;
  164|  15.6k|      }
  165|  15.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  15.6k|      {
   73|  15.6k|#if defined( __cpp_exceptions )
   74|  15.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  15.6k|            try {
   76|  15.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  15.6k|            }
   78|  15.6k|            catch( ... ) {
   79|  15.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  15.6k|               throw;
   81|  15.6k|            }
   82|  15.6k|         }
   83|  15.6k|         else {
   84|  15.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  15.6k|      {
   59|  15.6k|         return Rule::match( in );
   60|  15.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  24.0k|   {
  104|  24.0k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  24.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  24.0k|      }
  107|  24.0k|      else {
  108|  24.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  24.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  24.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  24.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  24.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  24.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  24.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  24.0k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  24.0k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  24.0k|         }
  128|       |
  129|  24.0k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  24.0k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  24.0k|         }
  132|       |
  133|  24.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  24.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  24.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.35k, False: 19.7k]
  ------------------
  143|  4.35k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.35k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.35k|            }
  146|  4.35k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.35k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.35k|            }
  149|  4.35k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.35k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.35k|            }
  152|  4.35k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.35k|            }
  155|  4.35k|         }
  156|  24.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.35k, False: 19.7k]
  ------------------
  157|  4.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.35k|         }
  159|  19.7k|         else {
  160|  19.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.7k|         }
  162|  24.0k|         (void)m( result );
  163|  24.0k|         return result;
  164|  24.0k|      }
  165|  24.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  24.0k|      {
   73|  24.0k|#if defined( __cpp_exceptions )
   74|  24.0k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  24.0k|            try {
   76|  24.0k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  24.0k|            }
   78|  24.0k|            catch( ... ) {
   79|  24.0k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  24.0k|               throw;
   81|  24.0k|            }
   82|  24.0k|         }
   83|  24.0k|         else {
   84|  24.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  24.0k|      {
   59|  24.0k|         return Rule::match( in );
   60|  24.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.83k, False: 697]
  ------------------
  143|  3.83k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.83k|            }
  146|  3.83k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.83k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.83k|            }
  149|  3.83k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.83k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.83k|            }
  152|  3.83k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.83k|            }
  155|  3.83k|         }
  156|  4.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.83k, False: 697]
  ------------------
  157|  3.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.83k|         }
  159|    697|         else {
  160|    697|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    697|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.53k|      {
   73|  4.53k|#if defined( __cpp_exceptions )
   74|  4.53k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.53k|            try {
   76|  4.53k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.53k|            }
   78|  4.53k|            catch( ... ) {
   79|  4.53k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.53k|               throw;
   81|  4.53k|            }
   82|  4.53k|         }
   83|  4.53k|         else {
   84|  4.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.53k|      {
   44|  4.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.21k, False: 1.31k]
  ------------------
  143|  3.21k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.21k|            }
  146|  3.21k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.21k|            }
  149|  3.21k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.21k|            }
  152|  3.21k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.21k|            }
  155|  3.21k|         }
  156|  4.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 1.31k]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|  1.31k|         else {
  160|  1.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.31k|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.53k|      {
   73|  4.53k|#if defined( __cpp_exceptions )
   74|  4.53k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.53k|            try {
   76|  4.53k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.53k|            }
   78|  4.53k|            catch( ... ) {
   79|  4.53k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.53k|               throw;
   81|  4.53k|            }
   82|  4.53k|         }
   83|  4.53k|         else {
   84|  4.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.53k|      {
   44|  4.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.53k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.53k, False: 0]
  ------------------
  143|  4.53k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.53k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.53k|            }
  146|  4.53k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.53k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.53k|            }
  149|  4.53k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.53k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.53k|            }
  152|  4.53k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.53k|            }
  155|  4.53k|         }
  156|  4.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.53k, False: 0]
  ------------------
  157|  4.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.53k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.53k|      {
   73|  4.53k|#if defined( __cpp_exceptions )
   74|  4.53k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.53k|            try {
   76|  4.53k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.53k|            }
   78|  4.53k|            catch( ... ) {
   79|  4.53k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.53k|               throw;
   81|  4.53k|            }
   82|  4.53k|         }
   83|  4.53k|         else {
   84|  4.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.53k|      {
   44|  4.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.53k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  143|  4.53k|            if constexpr( has_apply_void ) {
  144|  4.53k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.53k|            }
  146|  4.53k|            else if constexpr( has_apply_bool ) {
  147|  4.53k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.53k|            }
  149|  4.53k|            else if constexpr( has_apply0_void ) {
  150|  4.53k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.53k|            }
  152|  4.53k|            else if constexpr( has_apply0_bool ) {
  153|  4.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.53k|            }
  155|  4.53k|         }
  156|  4.53k|         if( result ) {
  157|  4.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.53k|         }
  159|  4.53k|         else {
  160|  4.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.53k|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.53k|      {
   44|  4.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.07k, False: 2.45k]
  ------------------
  143|  2.07k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.07k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.07k|            }
  146|  2.07k|            else if constexpr( has_apply_bool ) {
  147|  2.07k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.07k|            }
  149|  2.07k|            else if constexpr( has_apply0_void ) {
  150|  2.07k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.07k|            }
  152|  2.07k|            else if constexpr( has_apply0_bool ) {
  153|  2.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.07k|            }
  155|  2.07k|         }
  156|  4.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.07k, False: 2.45k]
  ------------------
  157|  2.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.07k|         }
  159|  2.45k|         else {
  160|  2.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45k|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.53k|      {
   73|  4.53k|#if defined( __cpp_exceptions )
   74|  4.53k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.53k|            try {
   76|  4.53k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.53k|            }
   78|  4.53k|            catch( ... ) {
   79|  4.53k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.53k|               throw;
   81|  4.53k|            }
   82|  4.53k|         }
   83|  4.53k|         else {
   84|  4.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.53k|      {
   44|  4.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 371, False: 4.16k]
  ------------------
  143|    371|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    371|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    371|            }
  146|    371|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    371|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    371|            }
  149|    371|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    371|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    371|            }
  152|    371|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    371|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    371|            }
  155|    371|         }
  156|  4.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 371, False: 4.16k]
  ------------------
  157|    371|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    371|         }
  159|  4.16k|         else {
  160|  4.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.16k|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.53k|      {
   73|  4.53k|#if defined( __cpp_exceptions )
   74|  4.53k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.53k|            try {
   76|  4.53k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.53k|            }
   78|  4.53k|            catch( ... ) {
   79|  4.53k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.53k|               throw;
   81|  4.53k|            }
   82|  4.53k|         }
   83|  4.53k|         else {
   84|  4.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.53k|      {
   59|  4.53k|         return Rule::match( in );
   60|  4.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.16k|   {
  104|  4.16k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.16k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.16k|      }
  107|  4.16k|      else {
  108|  4.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.16k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.16k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.16k|         }
  128|       |
  129|  4.16k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.16k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.16k|         }
  132|       |
  133|  4.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 231, False: 3.93k]
  ------------------
  143|    231|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    231|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    231|            }
  146|    231|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    231|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    231|            }
  149|    231|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    231|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    231|            }
  152|    231|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    231|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    231|            }
  155|    231|         }
  156|  4.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 231, False: 3.93k]
  ------------------
  157|    231|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    231|         }
  159|  3.93k|         else {
  160|  3.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.93k|         }
  162|  4.16k|         (void)m( result );
  163|  4.16k|         return result;
  164|  4.16k|      }
  165|  4.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.16k|      {
   73|  4.16k|#if defined( __cpp_exceptions )
   74|  4.16k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.16k|            try {
   76|  4.16k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.16k|            }
   78|  4.16k|            catch( ... ) {
   79|  4.16k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.16k|               throw;
   81|  4.16k|            }
   82|  4.16k|         }
   83|  4.16k|         else {
   84|  4.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.16k|      {
   59|  4.16k|         return Rule::match( in );
   60|  4.16k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.93k|   {
  104|  3.93k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.93k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.93k|      }
  107|  3.93k|      else {
  108|  3.93k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.93k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.93k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.93k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.93k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.93k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.93k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.93k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.93k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.93k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.93k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.93k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.93k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.93k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.93k|         }
  128|       |
  129|  3.93k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.93k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.93k|         }
  132|       |
  133|  3.93k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.93k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.93k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.93k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.93k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.93k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.93k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.93k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 559, False: 3.37k]
  ------------------
  143|    559|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    559|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    559|            }
  146|    559|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    559|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    559|            }
  149|    559|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    559|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    559|            }
  152|    559|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    559|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    559|            }
  155|    559|         }
  156|  3.93k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 559, False: 3.37k]
  ------------------
  157|    559|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    559|         }
  159|  3.37k|         else {
  160|  3.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.37k|         }
  162|  3.93k|         (void)m( result );
  163|  3.93k|         return result;
  164|  3.93k|      }
  165|  3.93k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.93k|      {
   73|  3.93k|#if defined( __cpp_exceptions )
   74|  3.93k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.93k|            try {
   76|  3.93k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.93k|            }
   78|  3.93k|            catch( ... ) {
   79|  3.93k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.93k|               throw;
   81|  3.93k|            }
   82|  3.93k|         }
   83|  3.93k|         else {
   84|  3.93k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.93k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.93k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.93k|      {
   59|  3.93k|         return Rule::match( in );
   60|  3.93k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.37k|   {
  104|  3.37k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.37k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.37k|      }
  107|  3.37k|      else {
  108|  3.37k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.37k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.37k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.37k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.37k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.37k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.37k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.37k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.37k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.37k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.37k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.37k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.37k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.37k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.37k|         }
  128|       |
  129|  3.37k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.37k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.37k|         }
  132|       |
  133|  3.37k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.37k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.37k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.37k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.37k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.37k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.37k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.37k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 207, False: 3.16k]
  ------------------
  143|    207|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    207|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    207|            }
  146|    207|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    207|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    207|            }
  149|    207|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    207|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    207|            }
  152|    207|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    207|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    207|            }
  155|    207|         }
  156|  3.37k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 207, False: 3.16k]
  ------------------
  157|    207|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    207|         }
  159|  3.16k|         else {
  160|  3.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.16k|         }
  162|  3.37k|         (void)m( result );
  163|  3.37k|         return result;
  164|  3.37k|      }
  165|  3.37k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.37k|      {
   73|  3.37k|#if defined( __cpp_exceptions )
   74|  3.37k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.37k|            try {
   76|  3.37k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.37k|            }
   78|  3.37k|            catch( ... ) {
   79|  3.37k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.37k|               throw;
   81|  3.37k|            }
   82|  3.37k|         }
   83|  3.37k|         else {
   84|  3.37k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.37k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.37k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.37k|      {
   59|  3.37k|         return Rule::match( in );
   60|  3.37k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.16k|   {
  104|  3.16k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.16k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.16k|      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.16k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.16k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.16k|         }
  128|       |
  129|  3.16k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.16k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.16k|         }
  132|       |
  133|  3.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 488, False: 2.67k]
  ------------------
  143|    488|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    488|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    488|            }
  146|    488|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    488|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    488|            }
  149|    488|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    488|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    488|            }
  152|    488|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    488|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    488|            }
  155|    488|         }
  156|  3.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 488, False: 2.67k]
  ------------------
  157|    488|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    488|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.16k|      {
   73|  3.16k|#if defined( __cpp_exceptions )
   74|  3.16k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.16k|            try {
   76|  3.16k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.16k|            }
   78|  3.16k|            catch( ... ) {
   79|  3.16k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.16k|               throw;
   81|  3.16k|            }
   82|  3.16k|         }
   83|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.16k|      {
   59|  3.16k|         return Rule::match( in );
   60|  3.16k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.67k|   {
  104|  2.67k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.67k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.67k|      }
  107|  2.67k|      else {
  108|  2.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.67k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.67k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.67k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.67k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.67k|         }
  128|       |
  129|  2.67k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.67k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.67k|         }
  132|       |
  133|  2.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.67k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.67k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 220, False: 2.45k]
  ------------------
  143|    220|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    220|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    220|            }
  146|    220|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    220|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    220|            }
  149|    220|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    220|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    220|            }
  152|    220|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    220|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    220|            }
  155|    220|         }
  156|  2.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 220, False: 2.45k]
  ------------------
  157|    220|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    220|         }
  159|  2.45k|         else {
  160|  2.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45k|         }
  162|  2.67k|         (void)m( result );
  163|  2.67k|         return result;
  164|  2.67k|      }
  165|  2.67k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.67k|      {
   73|  2.67k|#if defined( __cpp_exceptions )
   74|  2.67k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.67k|            try {
   76|  2.67k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.67k|            }
   78|  2.67k|            catch( ... ) {
   79|  2.67k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.67k|               throw;
   81|  2.67k|            }
   82|  2.67k|         }
   83|  2.67k|         else {
   84|  2.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.67k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.67k|      {
   59|  2.67k|         return Rule::match( in );
   60|  2.67k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.53k|   {
  104|  4.53k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.53k|      }
  107|  4.53k|      else {
  108|  4.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.53k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.53k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.53k|         }
  128|       |
  129|  4.53k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.53k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.53k|         }
  132|       |
  133|  4.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.41k, False: 1.12k]
  ------------------
  143|  3.41k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.41k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.41k|            }
  146|  3.41k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.41k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.41k|            }
  149|  3.41k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.41k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.41k|            }
  152|  3.41k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.41k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.41k|            }
  155|  3.41k|         }
  156|  4.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.41k, False: 1.12k]
  ------------------
  157|  3.41k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.41k|         }
  159|  1.12k|         else {
  160|  1.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.12k|         }
  162|  4.53k|         (void)m( result );
  163|  4.53k|         return result;
  164|  4.53k|      }
  165|  4.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.53k|      {
   73|  4.53k|#if defined( __cpp_exceptions )
   74|  4.53k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.53k|            try {
   76|  4.53k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.53k|            }
   78|  4.53k|            catch( ... ) {
   79|  4.53k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.53k|               throw;
   81|  4.53k|            }
   82|  4.53k|         }
   83|  4.53k|         else {
   84|  4.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.53k|      {
   59|  4.53k|         return Rule::match( in );
   60|  4.53k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.76k, False: 0]
  ------------------
  143|  6.76k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.76k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.76k|            }
  146|  6.76k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.76k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.76k|            }
  149|  6.76k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.76k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.76k|            }
  152|  6.76k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.76k|            }
  155|  6.76k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.76k, False: 0]
  ------------------
  157|  6.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.76k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.41k|   {
  104|  3.41k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.41k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.41k|      }
  107|  3.41k|      else {
  108|  3.41k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.41k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.41k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.41k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.41k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.41k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.41k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.41k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.41k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.41k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.41k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.41k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.41k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.41k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.41k|         }
  128|       |
  129|  3.41k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.41k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.41k|         }
  132|       |
  133|  3.41k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.41k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.41k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.41k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.41k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.41k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.41k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.41k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.35k, False: 54]
  ------------------
  143|  3.35k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.35k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.35k|            }
  146|  3.35k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.35k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.35k|            }
  149|  3.35k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.35k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.35k|            }
  152|  3.35k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.35k|            }
  155|  3.35k|         }
  156|  3.41k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.35k, False: 54]
  ------------------
  157|  3.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.35k|         }
  159|     54|         else {
  160|     54|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     54|         }
  162|  3.41k|         (void)m( result );
  163|  3.41k|         return result;
  164|  3.41k|      }
  165|  3.41k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.41k|      {
   73|  3.41k|#if defined( __cpp_exceptions )
   74|  3.41k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.41k|            try {
   76|  3.41k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.41k|            }
   78|  3.41k|            catch( ... ) {
   79|  3.41k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.41k|               throw;
   81|  3.41k|            }
   82|  3.41k|         }
   83|  3.41k|         else {
   84|  3.41k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.41k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.41k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.41k|      {
   44|  3.41k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.41k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.36k|   {
  104|  3.36k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.36k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.36k|      }
  107|  3.36k|      else {
  108|  3.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.36k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.36k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.36k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.36k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.36k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.36k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.36k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.36k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.36k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.36k|         }
  128|       |
  129|  3.36k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.36k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.36k|         }
  132|       |
  133|  3.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.36k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.36k|         if( result ) {
  143|  3.36k|            if constexpr( has_apply_void ) {
  144|  3.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.36k|            }
  146|  3.36k|            else if constexpr( has_apply_bool ) {
  147|  3.36k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.36k|            }
  149|  3.36k|            else if constexpr( has_apply0_void ) {
  150|  3.36k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.36k|            }
  152|  3.36k|            else if constexpr( has_apply0_bool ) {
  153|  3.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.36k|            }
  155|  3.36k|         }
  156|  3.36k|         if( result ) {
  157|  3.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.36k|         }
  159|  3.36k|         else {
  160|  3.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.36k|         }
  162|  3.36k|         (void)m( result );
  163|  3.36k|         return result;
  164|  3.36k|      }
  165|  3.36k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.36k|      {
   44|  3.36k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.36k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.99k|   {
  104|  8.99k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  8.99k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  8.99k|      }
  107|  8.99k|      else {
  108|  8.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  8.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  8.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  8.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  8.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  8.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  8.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  8.99k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  8.99k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  8.99k|         }
  128|       |
  129|  8.99k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  8.99k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  8.99k|         }
  132|       |
  133|  8.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  8.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.99k|         if( result ) {
  143|  8.99k|            if constexpr( has_apply_void ) {
  144|  8.99k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  8.99k|            }
  146|  8.99k|            else if constexpr( has_apply_bool ) {
  147|  8.99k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  8.99k|            }
  149|  8.99k|            else if constexpr( has_apply0_void ) {
  150|  8.99k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  8.99k|            }
  152|  8.99k|            else if constexpr( has_apply0_bool ) {
  153|  8.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.99k|            }
  155|  8.99k|         }
  156|  8.99k|         if( result ) {
  157|  8.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.99k|         }
  159|  8.99k|         else {
  160|  8.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.99k|         }
  162|  8.99k|         (void)m( result );
  163|  8.99k|         return result;
  164|  8.99k|      }
  165|  8.99k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.99k|      {
   44|  8.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.99k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.35k|   {
  104|  3.35k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.35k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.35k|      }
  107|  3.35k|      else {
  108|  3.35k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.35k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.35k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.35k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.35k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.35k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.35k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.35k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.35k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.35k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.35k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.35k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.35k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.35k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.35k|         }
  128|       |
  129|  3.35k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.35k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.35k|         }
  132|       |
  133|  3.35k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.35k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.35k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.35k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.35k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.35k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.35k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.35k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.21k, False: 139]
  ------------------
  143|  3.21k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.21k|            }
  146|  3.21k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.21k|            }
  149|  3.21k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.21k|            }
  152|  3.21k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.21k|            }
  155|  3.21k|         }
  156|  3.35k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 139]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|    139|         else {
  160|    139|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    139|         }
  162|  3.35k|         (void)m( result );
  163|  3.35k|         return result;
  164|  3.35k|      }
  165|  3.35k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.35k|      {
   73|  3.35k|#if defined( __cpp_exceptions )
   74|  3.35k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.35k|            try {
   76|  3.35k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.35k|            }
   78|  3.35k|            catch( ... ) {
   79|  3.35k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.35k|               throw;
   81|  3.35k|            }
   82|  3.35k|         }
   83|  3.35k|         else {
   84|  3.35k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.35k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.35k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.35k|      {
   59|  3.35k|         return Rule::match( in );
   60|  3.35k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.1k|   {
  104|  11.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  11.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  11.1k|      }
  107|  11.1k|      else {
  108|  11.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  11.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  11.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  11.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  11.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  11.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  11.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  11.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  11.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  11.1k|         }
  128|       |
  129|  11.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  11.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  11.1k|         }
  132|       |
  133|  11.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  11.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.68k, False: 1.42k]
  ------------------
  143|  9.68k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.68k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.68k|            }
  146|  9.68k|            else if constexpr( has_apply_bool ) {
  147|  9.68k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.68k|            }
  149|  9.68k|            else if constexpr( has_apply0_void ) {
  150|  9.68k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.68k|            }
  152|  9.68k|            else if constexpr( has_apply0_bool ) {
  153|  9.68k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.68k|            }
  155|  9.68k|         }
  156|  11.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.61k, False: 1.49k]
  ------------------
  157|  9.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.61k|         }
  159|  1.49k|         else {
  160|  1.49k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.49k|         }
  162|  11.1k|         (void)m( result );
  163|  11.1k|         return result;
  164|  11.1k|      }
  165|  11.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.1k|      {
   73|  11.1k|#if defined( __cpp_exceptions )
   74|  11.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  11.1k|            try {
   76|  11.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  11.1k|            }
   78|  11.1k|            catch( ... ) {
   79|  11.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  11.1k|               throw;
   81|  11.1k|            }
   82|  11.1k|         }
   83|  11.1k|         else {
   84|  11.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.1k|      {
   44|  11.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  11.1k|   {
  104|  11.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  11.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  11.1k|      }
  107|  11.1k|      else {
  108|  11.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  11.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  11.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  11.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  11.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  11.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  11.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  11.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  11.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  11.1k|         }
  128|       |
  129|  11.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  11.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  11.1k|         }
  132|       |
  133|  11.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  11.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.98k, False: 1.12k]
  ------------------
  143|  9.98k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.98k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.98k|            }
  146|  9.98k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  9.98k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.98k|            }
  149|  9.98k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  9.98k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.98k|            }
  152|  9.98k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  9.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.98k|            }
  155|  9.98k|         }
  156|  11.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.98k, False: 1.12k]
  ------------------
  157|  9.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.98k|         }
  159|  1.12k|         else {
  160|  1.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.12k|         }
  162|  11.1k|         (void)m( result );
  163|  11.1k|         return result;
  164|  11.1k|      }
  165|  11.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  11.1k|      {
   73|  11.1k|#if defined( __cpp_exceptions )
   74|  11.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  11.1k|            try {
   76|  11.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  11.1k|            }
   78|  11.1k|            catch( ... ) {
   79|  11.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  11.1k|               throw;
   81|  11.1k|            }
   82|  11.1k|         }
   83|  11.1k|         else {
   84|  11.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  11.1k|      {
   59|  11.1k|         return Rule::match( in );
   60|  11.1k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.98k|   {
  104|  9.98k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.98k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.98k|      }
  107|  9.98k|      else {
  108|  9.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  9.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  9.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  9.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  9.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  9.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  9.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.98k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  9.98k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.98k|         }
  128|       |
  129|  9.98k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  9.98k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.98k|         }
  132|       |
  133|  9.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  9.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.98k|         if( result ) {
  143|  9.98k|            if constexpr( has_apply_void ) {
  144|  9.98k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.98k|            }
  146|  9.98k|            else if constexpr( has_apply_bool ) {
  147|  9.98k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.98k|            }
  149|  9.98k|            else if constexpr( has_apply0_void ) {
  150|  9.98k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.98k|            }
  152|  9.98k|            else if constexpr( has_apply0_bool ) {
  153|  9.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.98k|            }
  155|  9.98k|         }
  156|  9.98k|         if( result ) {
  157|  9.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.98k|         }
  159|  9.98k|         else {
  160|  9.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.98k|         }
  162|  9.98k|         (void)m( result );
  163|  9.98k|         return result;
  164|  9.98k|      }
  165|  9.98k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.98k|      {
   44|  9.98k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.98k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.98k|   {
  104|  9.98k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.98k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.98k|      }
  107|  9.98k|      else {
  108|  9.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.98k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.98k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.98k|         }
  128|       |
  129|  9.98k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.98k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.98k|         }
  132|       |
  133|  9.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.98k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.68k, False: 303]
  ------------------
  143|  9.68k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.68k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.68k|            }
  146|  9.68k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  9.68k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.68k|            }
  149|  9.68k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  9.68k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.68k|            }
  152|  9.68k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  9.68k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.68k|            }
  155|  9.68k|         }
  156|  9.98k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.68k, False: 303]
  ------------------
  157|  9.68k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.68k|         }
  159|    303|         else {
  160|    303|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    303|         }
  162|  9.98k|         (void)m( result );
  163|  9.98k|         return result;
  164|  9.98k|      }
  165|  9.98k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.98k|      {
   73|  9.98k|#if defined( __cpp_exceptions )
   74|  9.98k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.98k|            try {
   76|  9.98k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.98k|            }
   78|  9.98k|            catch( ... ) {
   79|  9.98k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.98k|               throw;
   81|  9.98k|            }
   82|  9.98k|         }
   83|  9.98k|         else {
   84|  9.98k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.98k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.98k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.98k|      {
   44|  9.98k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.98k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.71M|   {
  104|  9.71M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.71M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.71M|      }
  107|  9.71M|      else {
  108|  9.71M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.71M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.71M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.71M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.71M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.71M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.71M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.71M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.71M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.71M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.71M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.71M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.71M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.71M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.71M|         }
  128|       |
  129|  9.71M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.71M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.71M|         }
  132|       |
  133|  9.71M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.71M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.71M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.71M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.71M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.71M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.71M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.71M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.68k, False: 9.70M]
  ------------------
  143|  9.68k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.68k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.68k|            }
  146|  9.68k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  9.68k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.68k|            }
  149|  9.68k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  9.68k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.68k|            }
  152|  9.68k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  9.68k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.68k|            }
  155|  9.68k|         }
  156|  9.71M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.68k, False: 9.70M]
  ------------------
  157|  9.68k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.68k|         }
  159|  9.70M|         else {
  160|  9.70M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.70M|         }
  162|  9.71M|         (void)m( result );
  163|  9.71M|         return result;
  164|  9.71M|      }
  165|  9.71M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.71M|      {
   73|  9.71M|#if defined( __cpp_exceptions )
   74|  9.71M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.71M|            try {
   76|  9.71M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.71M|            }
   78|  9.71M|            catch( ... ) {
   79|  9.71M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.71M|               throw;
   81|  9.71M|            }
   82|  9.71M|         }
   83|  9.71M|         else {
   84|  9.71M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.71M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.71M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.71M|      {
   59|  9.71M|         return Rule::match( in );
   60|  9.71M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.70M|   {
  104|  9.70M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.70M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.70M|      }
  107|  9.70M|      else {
  108|  9.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.70M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.70M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.70M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.70M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.70M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.70M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.70M|         }
  128|       |
  129|  9.70M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.70M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.70M|         }
  132|       |
  133|  9.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.70M, False: 303]
  ------------------
  143|  9.70M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.70M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.70M|            }
  146|  9.70M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  9.70M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.70M|            }
  149|  9.70M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  9.70M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.70M|            }
  152|  9.70M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  9.70M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.70M|            }
  155|  9.70M|         }
  156|  9.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.70M, False: 303]
  ------------------
  157|  9.70M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.70M|         }
  159|    303|         else {
  160|    303|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    303|         }
  162|  9.70M|         (void)m( result );
  163|  9.70M|         return result;
  164|  9.70M|      }
  165|  9.70M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.70M|      {
   73|  9.70M|#if defined( __cpp_exceptions )
   74|  9.70M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.70M|            try {
   76|  9.70M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.70M|            }
   78|  9.70M|            catch( ... ) {
   79|  9.70M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.70M|               throw;
   81|  9.70M|            }
   82|  9.70M|         }
   83|  9.70M|         else {
   84|  9.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.70M|      {
   44|  9.70M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.70M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.70M|   {
  104|  9.70M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.70M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.70M|      }
  107|  9.70M|      else {
  108|  9.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.70M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.70M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.70M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.70M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.70M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.70M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.70M|         }
  128|       |
  129|  9.70M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.70M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.70M|         }
  132|       |
  133|  9.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 107k, False: 9.59M]
  ------------------
  143|   107k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   107k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   107k|            }
  146|   107k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   107k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   107k|            }
  149|   107k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   107k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   107k|            }
  152|   107k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   107k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   107k|            }
  155|   107k|         }
  156|  9.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 107k, False: 9.59M]
  ------------------
  157|   107k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   107k|         }
  159|  9.59M|         else {
  160|  9.59M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.59M|         }
  162|  9.70M|         (void)m( result );
  163|  9.70M|         return result;
  164|  9.70M|      }
  165|  9.70M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.70M|      {
   73|  9.70M|#if defined( __cpp_exceptions )
   74|  9.70M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.70M|            try {
   76|  9.70M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.70M|            }
   78|  9.70M|            catch( ... ) {
   79|  9.70M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.70M|               throw;
   81|  9.70M|            }
   82|  9.70M|         }
   83|  9.70M|         else {
   84|  9.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.70M|      {
   44|  9.70M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.70M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.70M|   {
  104|  9.70M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.70M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.70M|      }
  107|  9.70M|      else {
  108|  9.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.70M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.70M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.70M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.70M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.70M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.70M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.70M|         }
  128|       |
  129|  9.70M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.70M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.70M|         }
  132|       |
  133|  9.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 107k, False: 9.59M]
  ------------------
  143|   107k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   107k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   107k|            }
  146|   107k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   107k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   107k|            }
  149|   107k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   107k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   107k|            }
  152|   107k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   107k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   107k|            }
  155|   107k|         }
  156|  9.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 107k, False: 9.59M]
  ------------------
  157|   107k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   107k|         }
  159|  9.59M|         else {
  160|  9.59M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.59M|         }
  162|  9.70M|         (void)m( result );
  163|  9.70M|         return result;
  164|  9.70M|      }
  165|  9.70M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.70M|      {
   73|  9.70M|#if defined( __cpp_exceptions )
   74|  9.70M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.70M|            try {
   76|  9.70M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.70M|            }
   78|  9.70M|            catch( ... ) {
   79|  9.70M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.70M|               throw;
   81|  9.70M|            }
   82|  9.70M|         }
   83|  9.70M|         else {
   84|  9.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.70M|      {
   59|  9.70M|         return Rule::match( in );
   60|  9.70M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   107k|   {
  104|   107k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   107k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   107k|      }
  107|   107k|      else {
  108|   107k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   107k|         using iterator_t = typename ParseInput::iterator_t;
  111|   107k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   107k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   107k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   107k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   107k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   107k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   107k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   107k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   107k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   107k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   107k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   107k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   107k|         }
  128|       |
  129|   107k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   107k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   107k|         }
  132|       |
  133|   107k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   107k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   107k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   107k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   107k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   107k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   107k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   107k|         if( result ) {
  143|   107k|            if constexpr( has_apply_void ) {
  144|   107k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   107k|            }
  146|   107k|            else if constexpr( has_apply_bool ) {
  147|   107k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   107k|            }
  149|   107k|            else if constexpr( has_apply0_void ) {
  150|   107k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   107k|            }
  152|   107k|            else if constexpr( has_apply0_bool ) {
  153|   107k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   107k|            }
  155|   107k|         }
  156|   107k|         if( result ) {
  157|   107k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   107k|         }
  159|   107k|         else {
  160|   107k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   107k|         }
  162|   107k|         (void)m( result );
  163|   107k|         return result;
  164|   107k|      }
  165|   107k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   107k|      {
   44|   107k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   107k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   107k|   {
  104|   107k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   107k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   107k|      }
  107|   107k|      else {
  108|   107k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   107k|         using iterator_t = typename ParseInput::iterator_t;
  111|   107k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   107k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   107k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   107k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   107k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   107k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   107k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   107k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   107k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   107k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   107k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   107k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   107k|         }
  128|       |
  129|   107k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   107k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   107k|         }
  132|       |
  133|   107k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   107k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   107k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   107k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   107k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   107k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   107k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   107k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 107k, False: 107]
  ------------------
  143|   107k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   107k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   107k|            }
  146|   107k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   107k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   107k|            }
  149|   107k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   107k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   107k|            }
  152|   107k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   107k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   107k|            }
  155|   107k|         }
  156|   107k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 107k, False: 107]
  ------------------
  157|   107k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   107k|         }
  159|    107|         else {
  160|    107|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    107|         }
  162|   107k|         (void)m( result );
  163|   107k|         return result;
  164|   107k|      }
  165|   107k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   107k|      {
   73|   107k|#if defined( __cpp_exceptions )
   74|   107k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   107k|            try {
   76|   107k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   107k|            }
   78|   107k|            catch( ... ) {
   79|   107k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   107k|               throw;
   81|   107k|            }
   82|   107k|         }
   83|   107k|         else {
   84|   107k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   107k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   107k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   107k|      {
   44|   107k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   107k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   107k|   {
  104|   107k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   107k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   107k|      }
  107|   107k|      else {
  108|   107k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   107k|         using iterator_t = typename ParseInput::iterator_t;
  111|   107k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   107k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   107k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   107k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   107k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   107k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   107k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   107k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   107k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   107k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   107k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   107k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   107k|         }
  128|       |
  129|   107k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   107k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   107k|         }
  132|       |
  133|   107k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   107k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   107k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   107k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   107k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   107k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   107k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   107k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.2k, False: 68.0k]
  ------------------
  143|  39.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  39.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  39.2k|            }
  146|  39.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  39.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  39.2k|            }
  149|  39.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  39.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  39.2k|            }
  152|  39.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  39.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.2k|            }
  155|  39.2k|         }
  156|   107k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.2k, False: 68.0k]
  ------------------
  157|  39.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.2k|         }
  159|  68.0k|         else {
  160|  68.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  68.0k|         }
  162|   107k|         (void)m( result );
  163|   107k|         return result;
  164|   107k|      }
  165|   107k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   107k|      {
   73|   107k|#if defined( __cpp_exceptions )
   74|   107k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   107k|            try {
   76|   107k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   107k|            }
   78|   107k|            catch( ... ) {
   79|   107k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   107k|               throw;
   81|   107k|            }
   82|   107k|         }
   83|   107k|         else {
   84|   107k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   107k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   107k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   107k|      {
   44|   107k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   107k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   107k|   {
  104|   107k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   107k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   107k|      }
  107|   107k|      else {
  108|   107k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   107k|         using iterator_t = typename ParseInput::iterator_t;
  111|   107k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   107k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   107k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   107k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   107k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   107k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   107k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   107k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   107k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   107k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   107k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   107k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   107k|         }
  128|       |
  129|   107k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   107k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   107k|         }
  132|       |
  133|   107k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   107k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   107k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   107k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   107k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   107k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   107k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   107k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.3k, False: 67.9k]
  ------------------
  143|  39.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  39.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  39.3k|            }
  146|  39.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  39.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  39.3k|            }
  149|  39.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  39.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  39.3k|            }
  152|  39.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  39.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.3k|            }
  155|  39.3k|         }
  156|   107k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.3k, False: 67.9k]
  ------------------
  157|  39.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.3k|         }
  159|  67.9k|         else {
  160|  67.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.9k|         }
  162|   107k|         (void)m( result );
  163|   107k|         return result;
  164|   107k|      }
  165|   107k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   107k|      {
   73|   107k|#if defined( __cpp_exceptions )
   74|   107k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   107k|            try {
   76|   107k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   107k|            }
   78|   107k|            catch( ... ) {
   79|   107k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   107k|               throw;
   81|   107k|            }
   82|   107k|         }
   83|   107k|         else {
   84|   107k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   107k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   107k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   107k|      {
   59|   107k|         return Rule::match( in );
   60|   107k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  39.3k|   {
  104|  39.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  39.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  39.3k|      }
  107|  39.3k|      else {
  108|  39.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  39.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  39.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  39.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  39.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  39.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  39.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  39.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  39.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  39.3k|         }
  128|       |
  129|  39.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  39.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  39.3k|         }
  132|       |
  133|  39.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  39.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  39.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.3k|         if( result ) {
  143|  39.3k|            if constexpr( has_apply_void ) {
  144|  39.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  39.3k|            }
  146|  39.3k|            else if constexpr( has_apply_bool ) {
  147|  39.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  39.3k|            }
  149|  39.3k|            else if constexpr( has_apply0_void ) {
  150|  39.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  39.3k|            }
  152|  39.3k|            else if constexpr( has_apply0_bool ) {
  153|  39.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.3k|            }
  155|  39.3k|         }
  156|  39.3k|         if( result ) {
  157|  39.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.3k|         }
  159|  39.3k|         else {
  160|  39.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  39.3k|         }
  162|  39.3k|         (void)m( result );
  163|  39.3k|         return result;
  164|  39.3k|      }
  165|  39.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  39.3k|      {
   44|  39.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.3k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  39.3k|   {
  104|  39.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  39.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  39.3k|      }
  107|  39.3k|      else {
  108|  39.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  39.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  39.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  39.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  39.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  39.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  39.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  39.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  39.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  39.3k|         }
  128|       |
  129|  39.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  39.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  39.3k|         }
  132|       |
  133|  39.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  39.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  39.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.2k, False: 46]
  ------------------
  143|  39.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  39.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  39.2k|            }
  146|  39.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  39.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  39.2k|            }
  149|  39.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  39.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  39.2k|            }
  152|  39.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  39.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.2k|            }
  155|  39.2k|         }
  156|  39.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.2k, False: 46]
  ------------------
  157|  39.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.2k|         }
  159|     46|         else {
  160|     46|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     46|         }
  162|  39.3k|         (void)m( result );
  163|  39.3k|         return result;
  164|  39.3k|      }
  165|  39.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  39.3k|      {
   73|  39.3k|#if defined( __cpp_exceptions )
   74|  39.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  39.3k|            try {
   76|  39.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  39.3k|            }
   78|  39.3k|            catch( ... ) {
   79|  39.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  39.3k|               throw;
   81|  39.3k|            }
   82|  39.3k|         }
   83|  39.3k|         else {
   84|  39.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  39.3k|      {
   44|  39.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  78.6k|   {
  104|  78.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  78.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  78.6k|      }
  107|  78.6k|      else {
  108|  78.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  78.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  78.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  78.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  78.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  78.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  78.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  78.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  78.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  78.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  78.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  78.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  78.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  78.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  78.6k|         }
  128|       |
  129|  78.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  78.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  78.6k|         }
  132|       |
  133|  78.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  78.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  78.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  78.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  78.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  78.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  78.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  78.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 78.5k, False: 46]
  ------------------
  143|  78.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  78.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  78.5k|            }
  146|  78.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  78.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  78.5k|            }
  149|  78.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  78.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  78.5k|            }
  152|  78.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  78.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  78.5k|            }
  155|  78.5k|         }
  156|  78.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 78.5k, False: 46]
  ------------------
  157|  78.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  78.5k|         }
  159|     46|         else {
  160|     46|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     46|         }
  162|  78.6k|         (void)m( result );
  163|  78.6k|         return result;
  164|  78.6k|      }
  165|  78.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  78.6k|      {
   73|  78.6k|#if defined( __cpp_exceptions )
   74|  78.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  78.6k|            try {
   76|  78.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  78.6k|            }
   78|  78.6k|            catch( ... ) {
   79|  78.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  78.6k|               throw;
   81|  78.6k|            }
   82|  78.6k|         }
   83|  78.6k|         else {
   84|  78.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  78.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  78.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  78.6k|      {
   59|  78.6k|         return Rule::match( in );
   60|  78.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  67.9k|   {
  104|  67.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  67.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  67.9k|      }
  107|  67.9k|      else {
  108|  67.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  67.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  67.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  67.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  67.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  67.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  67.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  67.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  67.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  67.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  67.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  67.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  67.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  67.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  67.9k|         }
  128|       |
  129|  67.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  67.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  67.9k|         }
  132|       |
  133|  67.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  67.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  67.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  67.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  67.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  67.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  67.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  67.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 23.2k, False: 44.7k]
  ------------------
  143|  23.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  23.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  23.2k|            }
  146|  23.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  23.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  23.2k|            }
  149|  23.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  23.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  23.2k|            }
  152|  23.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  23.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.2k|            }
  155|  23.2k|         }
  156|  67.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 23.2k, False: 44.7k]
  ------------------
  157|  23.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.2k|         }
  159|  44.7k|         else {
  160|  44.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.7k|         }
  162|  67.9k|         (void)m( result );
  163|  67.9k|         return result;
  164|  67.9k|      }
  165|  67.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  67.9k|      {
   73|  67.9k|#if defined( __cpp_exceptions )
   74|  67.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  67.9k|            try {
   76|  67.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  67.9k|            }
   78|  67.9k|            catch( ... ) {
   79|  67.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  67.9k|               throw;
   81|  67.9k|            }
   82|  67.9k|         }
   83|  67.9k|         else {
   84|  67.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  67.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  67.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  67.9k|      {
   44|  67.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  67.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  99.9k|   {
  104|  99.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  99.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  99.9k|      }
  107|  99.9k|      else {
  108|  99.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  99.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  99.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  99.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  99.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  99.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  99.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  99.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  99.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  99.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  99.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  99.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  99.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  99.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  99.9k|         }
  128|       |
  129|  99.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  99.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  99.9k|         }
  132|       |
  133|  99.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  99.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  99.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  99.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  99.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  99.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  99.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  99.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.6k, False: 62.2k]
  ------------------
  143|  37.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  37.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  37.6k|            }
  146|  37.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  37.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  37.6k|            }
  149|  37.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  37.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  37.6k|            }
  152|  37.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  37.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.6k|            }
  155|  37.6k|         }
  156|  99.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.6k, False: 62.2k]
  ------------------
  157|  37.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.6k|         }
  159|  62.2k|         else {
  160|  62.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  62.2k|         }
  162|  99.9k|         (void)m( result );
  163|  99.9k|         return result;
  164|  99.9k|      }
  165|  99.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  99.9k|      {
   73|  99.9k|#if defined( __cpp_exceptions )
   74|  99.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  99.9k|            try {
   76|  99.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  99.9k|            }
   78|  99.9k|            catch( ... ) {
   79|  99.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  99.9k|               throw;
   81|  99.9k|            }
   82|  99.9k|         }
   83|  99.9k|         else {
   84|  99.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  99.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  99.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  99.9k|      {
   59|  99.9k|         return Rule::match( in );
   60|  99.9k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  23.2k|   {
  104|  23.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.2k|      }
  107|  23.2k|      else {
  108|  23.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  23.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  23.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  23.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  23.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  23.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  23.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  23.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.2k|         }
  128|       |
  129|  23.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  23.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.2k|         }
  132|       |
  133|  23.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  23.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.2k|         if( result ) {
  143|  23.2k|            if constexpr( has_apply_void ) {
  144|  23.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  23.2k|            }
  146|  23.2k|            else if constexpr( has_apply_bool ) {
  147|  23.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  23.2k|            }
  149|  23.2k|            else if constexpr( has_apply0_void ) {
  150|  23.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  23.2k|            }
  152|  23.2k|            else if constexpr( has_apply0_bool ) {
  153|  23.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.2k|            }
  155|  23.2k|         }
  156|  23.2k|         if( result ) {
  157|  23.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.2k|         }
  159|  23.2k|         else {
  160|  23.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  23.2k|         }
  162|  23.2k|         (void)m( result );
  163|  23.2k|         return result;
  164|  23.2k|      }
  165|  23.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  23.2k|      {
   44|  23.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  23.2k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  23.2k|   {
  104|  23.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.2k|      }
  107|  23.2k|      else {
  108|  23.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  23.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  23.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  23.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  23.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  23.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  23.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  23.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.2k|         }
  128|       |
  129|  23.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  23.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.2k|         }
  132|       |
  133|  23.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  23.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 23.2k, False: 0]
  ------------------
  143|  23.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  23.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  23.2k|            }
  146|  23.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  23.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  23.2k|            }
  149|  23.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  23.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  23.2k|            }
  152|  23.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  23.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.2k|            }
  155|  23.2k|         }
  156|  23.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 23.2k, False: 0]
  ------------------
  157|  23.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.2k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  23.2k|         (void)m( result );
  163|  23.2k|         return result;
  164|  23.2k|      }
  165|  23.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  23.2k|      {
   73|  23.2k|#if defined( __cpp_exceptions )
   74|  23.2k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  23.2k|            try {
   76|  23.2k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  23.2k|            }
   78|  23.2k|            catch( ... ) {
   79|  23.2k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  23.2k|               throw;
   81|  23.2k|            }
   82|  23.2k|         }
   83|  23.2k|         else {
   84|  23.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  23.2k|      {
   44|  23.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  23.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.7k|   {
  104|  44.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  44.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  44.7k|      }
  107|  44.7k|      else {
  108|  44.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  44.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  44.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  44.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  44.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  44.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  44.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  44.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  44.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  44.7k|         }
  128|       |
  129|  44.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  44.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  44.7k|         }
  132|       |
  133|  44.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  44.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.7k, False: 1.03k]
  ------------------
  143|  43.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  43.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  43.7k|            }
  146|  43.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  43.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  43.7k|            }
  149|  43.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  43.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  43.7k|            }
  152|  43.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  43.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.7k|            }
  155|  43.7k|         }
  156|  44.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.7k, False: 1.03k]
  ------------------
  157|  43.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.7k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|  44.7k|         (void)m( result );
  163|  44.7k|         return result;
  164|  44.7k|      }
  165|  44.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.7k|      {
   73|  44.7k|#if defined( __cpp_exceptions )
   74|  44.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  44.7k|            try {
   76|  44.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  44.7k|            }
   78|  44.7k|            catch( ... ) {
   79|  44.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  44.7k|               throw;
   81|  44.7k|            }
   82|  44.7k|         }
   83|  44.7k|         else {
   84|  44.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  44.7k|      {
   59|  44.7k|         return Rule::match( in );
   60|  44.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.03k|   {
  104|  1.03k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.03k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.03k|      }
  107|  1.03k|      else {
  108|  1.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.03k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.03k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.03k|         }
  128|       |
  129|  1.03k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.03k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.03k|         }
  132|       |
  133|  1.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 969, False: 61]
  ------------------
  143|    969|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    969|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    969|            }
  146|    969|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    969|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    969|            }
  149|    969|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    969|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    969|            }
  152|    969|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    969|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    969|            }
  155|    969|         }
  156|  1.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 969, False: 61]
  ------------------
  157|    969|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    969|         }
  159|     61|         else {
  160|     61|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     61|         }
  162|  1.03k|         (void)m( result );
  163|  1.03k|         return result;
  164|  1.03k|      }
  165|  1.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.03k|      {
   73|  1.03k|#if defined( __cpp_exceptions )
   74|  1.03k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.03k|            try {
   76|  1.03k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.03k|            }
   78|  1.03k|            catch( ... ) {
   79|  1.03k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.03k|               throw;
   81|  1.03k|            }
   82|  1.03k|         }
   83|  1.03k|         else {
   84|  1.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.03k|      {
   59|  1.03k|         return Rule::match( in );
   60|  1.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.59M|   {
  104|  9.59M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.59M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.59M|      }
  107|  9.59M|      else {
  108|  9.59M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.59M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.59M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.59M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.59M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.59M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.59M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.59M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.59M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.59M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.59M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.59M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.59M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.59M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.59M|         }
  128|       |
  129|  9.59M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.59M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.59M|         }
  132|       |
  133|  9.59M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.59M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.59M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.59M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.59M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.59M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.59M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.59M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.59M, False: 196]
  ------------------
  143|  9.59M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  9.59M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  9.59M|            }
  146|  9.59M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  9.59M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  9.59M|            }
  149|  9.59M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  9.59M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  9.59M|            }
  152|  9.59M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  9.59M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.59M|            }
  155|  9.59M|         }
  156|  9.59M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.59M, False: 196]
  ------------------
  157|  9.59M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.59M|         }
  159|    196|         else {
  160|    196|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    196|         }
  162|  9.59M|         (void)m( result );
  163|  9.59M|         return result;
  164|  9.59M|      }
  165|  9.59M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.59M|      {
   73|  9.59M|#if defined( __cpp_exceptions )
   74|  9.59M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.59M|            try {
   76|  9.59M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.59M|            }
   78|  9.59M|            catch( ... ) {
   79|  9.59M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.59M|               throw;
   81|  9.59M|            }
   82|  9.59M|         }
   83|  9.59M|         else {
   84|  9.59M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.59M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.59M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.59M|      {
   59|  9.59M|         return Rule::match( in );
   60|  9.59M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser21parent_hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  32.9k|   {
  104|  32.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  32.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  32.9k|      }
  107|  32.9k|      else {
  108|  32.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  32.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  32.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  32.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  32.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  32.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  32.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  32.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  32.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  32.9k|         }
  128|       |
  129|  32.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  32.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  32.9k|         }
  132|       |
  133|  32.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  32.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  32.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 30.4k]
  ------------------
  143|  2.49k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.49k|            }
  146|  2.49k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.49k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.49k|            }
  149|  2.49k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.49k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.49k|            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  32.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 30.4k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  30.4k|         else {
  160|  30.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.4k|         }
  162|  32.9k|         (void)m( result );
  163|  32.9k|         return result;
  164|  32.9k|      }
  165|  32.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser21parent_hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  32.9k|      {
   73|  32.9k|#if defined( __cpp_exceptions )
   74|  32.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  32.9k|            try {
   76|  32.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  32.9k|            }
   78|  32.9k|            catch( ... ) {
   79|  32.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  32.9k|               throw;
   81|  32.9k|            }
   82|  32.9k|         }
   83|  32.9k|         else {
   84|  32.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser21parent_hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  32.9k|      {
   44|  32.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  32.9k|   {
  104|  32.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  32.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  32.9k|      }
  107|  32.9k|      else {
  108|  32.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  32.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  32.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  32.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  32.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  32.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  32.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  32.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  32.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  32.9k|         }
  128|       |
  129|  32.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  32.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  32.9k|         }
  132|       |
  133|  32.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  32.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  32.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 30.4k]
  ------------------
  143|  2.49k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.49k|            }
  146|  2.49k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.49k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.49k|            }
  149|  2.49k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.49k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.49k|            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  32.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 30.4k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  30.4k|         else {
  160|  30.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.4k|         }
  162|  32.9k|         (void)m( result );
  163|  32.9k|         return result;
  164|  32.9k|      }
  165|  32.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_15str_parent_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  32.9k|      {
   73|  32.9k|#if defined( __cpp_exceptions )
   74|  32.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  32.9k|            try {
   76|  32.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  32.9k|            }
   78|  32.9k|            catch( ... ) {
   79|  32.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  32.9k|               throw;
   81|  32.9k|            }
   82|  32.9k|         }
   83|  32.9k|         else {
   84|  32.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_15str_parent_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  32.9k|      {
   44|  32.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15str_parent_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  32.9k|   {
  104|  32.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  32.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  32.9k|      }
  107|  32.9k|      else {
  108|  32.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  32.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  32.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  32.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  32.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  32.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  32.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  32.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  32.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  32.9k|         }
  128|       |
  129|  32.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  32.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  32.9k|         }
  132|       |
  133|  32.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  32.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  32.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.05k, False: 29.8k]
  ------------------
  143|  3.05k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.05k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.05k|            }
  146|  3.05k|            else if constexpr( has_apply_bool ) {
  147|  3.05k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.05k|            }
  149|  3.05k|            else if constexpr( has_apply0_void ) {
  150|  3.05k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.05k|            }
  152|  3.05k|            else if constexpr( has_apply0_bool ) {
  153|  3.05k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.05k|            }
  155|  3.05k|         }
  156|  32.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.05k, False: 29.8k]
  ------------------
  157|  3.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.05k|         }
  159|  29.8k|         else {
  160|  29.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  29.8k|         }
  162|  32.9k|         (void)m( result );
  163|  32.9k|         return result;
  164|  32.9k|      }
  165|  32.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15str_parent_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  32.9k|      {
   73|  32.9k|#if defined( __cpp_exceptions )
   74|  32.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  32.9k|            try {
   76|  32.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  32.9k|            }
   78|  32.9k|            catch( ... ) {
   79|  32.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  32.9k|               throw;
   81|  32.9k|            }
   82|  32.9k|         }
   83|  32.9k|         else {
   84|  32.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15str_parent_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  32.9k|      {
   59|  32.9k|         return Rule::match( in );
   60|  32.9k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.44k|   {
  104|  9.44k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.44k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.44k|      }
  107|  9.44k|      else {
  108|  9.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.44k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.44k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.44k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.44k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.44k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.44k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.44k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.44k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.44k|         }
  128|       |
  129|  9.44k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.44k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.44k|         }
  132|       |
  133|  9.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.60k, False: 1.83k]
  ------------------
  143|  7.60k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.60k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.60k|            }
  146|  7.60k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.60k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.60k|            }
  149|  7.60k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.60k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.60k|            }
  152|  7.60k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.60k|            }
  155|  7.60k|         }
  156|  9.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.60k, False: 1.83k]
  ------------------
  157|  7.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.60k|         }
  159|  1.83k|         else {
  160|  1.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.83k|         }
  162|  9.44k|         (void)m( result );
  163|  9.44k|         return result;
  164|  9.44k|      }
  165|  9.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  9.44k|      {
   73|  9.44k|#if defined( __cpp_exceptions )
   74|  9.44k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.44k|            try {
   76|  9.44k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.44k|            }
   78|  9.44k|            catch( ... ) {
   79|  9.44k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.44k|               throw;
   81|  9.44k|            }
   82|  9.44k|         }
   83|  9.44k|         else {
   84|  9.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.44k|      {
   44|  9.44k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.44k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.44k|   {
  104|  9.44k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.44k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.44k|      }
  107|  9.44k|      else {
  108|  9.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.44k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.44k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.44k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.44k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.44k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.44k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.44k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.44k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.44k|         }
  128|       |
  129|  9.44k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.44k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.44k|         }
  132|       |
  133|  9.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.60k, False: 1.83k]
  ------------------
  143|  7.60k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.60k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.60k|            }
  146|  7.60k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.60k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.60k|            }
  149|  7.60k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.60k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.60k|            }
  152|  7.60k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.60k|            }
  155|  7.60k|         }
  156|  9.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.60k, False: 1.83k]
  ------------------
  157|  7.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.60k|         }
  159|  1.83k|         else {
  160|  1.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.83k|         }
  162|  9.44k|         (void)m( result );
  163|  9.44k|         return result;
  164|  9.44k|      }
  165|  9.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.44k|      {
   73|  9.44k|#if defined( __cpp_exceptions )
   74|  9.44k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.44k|            try {
   76|  9.44k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.44k|            }
   78|  9.44k|            catch( ... ) {
   79|  9.44k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.44k|               throw;
   81|  9.44k|            }
   82|  9.44k|         }
   83|  9.44k|         else {
   84|  9.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.44k|      {
   59|  9.44k|         return Rule::match( in );
   60|  9.44k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  17.9k|   {
  104|  17.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  17.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  17.9k|      }
  107|  17.9k|      else {
  108|  17.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  17.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  17.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  17.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  17.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  17.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  17.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  17.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  17.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  17.9k|         }
  128|       |
  129|  17.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  17.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  17.9k|         }
  132|       |
  133|  17.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  17.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  17.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.86k, False: 12.0k]
  ------------------
  143|  5.86k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.86k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.86k|            }
  146|  5.86k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.86k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.86k|            }
  149|  5.86k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.86k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.86k|            }
  152|  5.86k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.86k|            }
  155|  5.86k|         }
  156|  17.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.86k, False: 12.0k]
  ------------------
  157|  5.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.86k|         }
  159|  12.0k|         else {
  160|  12.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.0k|         }
  162|  17.9k|         (void)m( result );
  163|  17.9k|         return result;
  164|  17.9k|      }
  165|  17.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  17.9k|      {
   73|  17.9k|#if defined( __cpp_exceptions )
   74|  17.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  17.9k|            try {
   76|  17.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  17.9k|            }
   78|  17.9k|            catch( ... ) {
   79|  17.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  17.9k|               throw;
   81|  17.9k|            }
   82|  17.9k|         }
   83|  17.9k|         else {
   84|  17.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  17.9k|      {
   59|  17.9k|         return Rule::match( in );
   60|  17.9k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 549]
  ------------------
  143|  2.49k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.49k|            }
  146|  2.49k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.49k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.49k|            }
  149|  2.49k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.49k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.49k|            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 549]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|    549|         else {
  160|    549|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    549|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.04k|#if defined( __cpp_exceptions )
   74|  3.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.04k|            try {
   76|  3.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.04k|            }
   78|  3.04k|            catch( ... ) {
   79|  3.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.04k|               throw;
   81|  3.04k|            }
   82|  3.04k|         }
   83|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.04k|      {
   44|  3.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.07k, False: 966]
  ------------------
  143|  2.07k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.07k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.07k|            }
  146|  2.07k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.07k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.07k|            }
  149|  2.07k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.07k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.07k|            }
  152|  2.07k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.07k|            }
  155|  2.07k|         }
  156|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.07k, False: 966]
  ------------------
  157|  2.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.07k|         }
  159|    966|         else {
  160|    966|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    966|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.04k|#if defined( __cpp_exceptions )
   74|  3.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.04k|            try {
   76|  3.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.04k|            }
   78|  3.04k|            catch( ... ) {
   79|  3.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.04k|               throw;
   81|  3.04k|            }
   82|  3.04k|         }
   83|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.04k|      {
   44|  3.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.04k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.04k, False: 0]
  ------------------
  143|  3.04k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.04k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.04k|            }
  146|  3.04k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.04k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.04k|            }
  149|  3.04k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.04k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.04k|            }
  152|  3.04k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.04k|            }
  155|  3.04k|         }
  156|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.04k, False: 0]
  ------------------
  157|  3.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.04k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.04k|#if defined( __cpp_exceptions )
   74|  3.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.04k|            try {
   76|  3.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.04k|            }
   78|  3.04k|            catch( ... ) {
   79|  3.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.04k|               throw;
   81|  3.04k|            }
   82|  3.04k|         }
   83|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.04k|      {
   44|  3.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.04k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  143|  3.04k|            if constexpr( has_apply_void ) {
  144|  3.04k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.04k|            }
  146|  3.04k|            else if constexpr( has_apply_bool ) {
  147|  3.04k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.04k|            }
  149|  3.04k|            else if constexpr( has_apply0_void ) {
  150|  3.04k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.04k|            }
  152|  3.04k|            else if constexpr( has_apply0_bool ) {
  153|  3.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.04k|            }
  155|  3.04k|         }
  156|  3.04k|         if( result ) {
  157|  3.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.04k|         }
  159|  3.04k|         else {
  160|  3.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.04k|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.04k|      {
   44|  3.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44k, False: 1.59k]
  ------------------
  143|  1.44k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.44k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.44k|            }
  146|  1.44k|            else if constexpr( has_apply_bool ) {
  147|  1.44k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.44k|            }
  149|  1.44k|            else if constexpr( has_apply0_void ) {
  150|  1.44k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.44k|            }
  152|  1.44k|            else if constexpr( has_apply0_bool ) {
  153|  1.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.44k|            }
  155|  1.44k|         }
  156|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44k, False: 1.59k]
  ------------------
  157|  1.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44k|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.04k|#if defined( __cpp_exceptions )
   74|  3.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.04k|            try {
   76|  3.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.04k|            }
   78|  3.04k|            catch( ... ) {
   79|  3.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.04k|               throw;
   81|  3.04k|            }
   82|  3.04k|         }
   83|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.04k|      {
   44|  3.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 264, False: 2.77k]
  ------------------
  143|    264|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    264|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    264|            }
  146|    264|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    264|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    264|            }
  149|    264|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    264|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    264|            }
  152|    264|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    264|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    264|            }
  155|    264|         }
  156|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264, False: 2.77k]
  ------------------
  157|    264|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    264|         }
  159|  2.77k|         else {
  160|  2.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.77k|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.04k|#if defined( __cpp_exceptions )
   74|  3.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.04k|            try {
   76|  3.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.04k|            }
   78|  3.04k|            catch( ... ) {
   79|  3.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.04k|               throw;
   81|  3.04k|            }
   82|  3.04k|         }
   83|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.04k|      {
   59|  3.04k|         return Rule::match( in );
   60|  3.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.77k|   {
  104|  2.77k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.77k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.77k|      }
  107|  2.77k|      else {
  108|  2.77k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.77k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.77k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.77k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.77k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.77k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.77k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.77k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.77k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.77k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.77k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.77k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.77k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.77k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.77k|         }
  128|       |
  129|  2.77k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.77k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.77k|         }
  132|       |
  133|  2.77k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.77k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.77k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.77k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.77k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.77k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.77k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.77k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 210, False: 2.56k]
  ------------------
  143|    210|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    210|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    210|            }
  146|    210|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    210|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    210|            }
  149|    210|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    210|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    210|            }
  152|    210|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    210|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    210|            }
  155|    210|         }
  156|  2.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 210, False: 2.56k]
  ------------------
  157|    210|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    210|         }
  159|  2.56k|         else {
  160|  2.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.56k|         }
  162|  2.77k|         (void)m( result );
  163|  2.77k|         return result;
  164|  2.77k|      }
  165|  2.77k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.77k|      {
   73|  2.77k|#if defined( __cpp_exceptions )
   74|  2.77k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.77k|            try {
   76|  2.77k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.77k|            }
   78|  2.77k|            catch( ... ) {
   79|  2.77k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.77k|               throw;
   81|  2.77k|            }
   82|  2.77k|         }
   83|  2.77k|         else {
   84|  2.77k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.77k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.77k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.77k|      {
   59|  2.77k|         return Rule::match( in );
   60|  2.77k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.56k|   {
  104|  2.56k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.56k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.56k|      }
  107|  2.56k|      else {
  108|  2.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.56k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.56k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.56k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.56k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.56k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.56k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.56k|         }
  128|       |
  129|  2.56k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.56k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.56k|         }
  132|       |
  133|  2.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 457, False: 2.11k]
  ------------------
  143|    457|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    457|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    457|            }
  146|    457|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    457|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    457|            }
  149|    457|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    457|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    457|            }
  152|    457|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    457|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    457|            }
  155|    457|         }
  156|  2.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 457, False: 2.11k]
  ------------------
  157|    457|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    457|         }
  159|  2.11k|         else {
  160|  2.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.11k|         }
  162|  2.56k|         (void)m( result );
  163|  2.56k|         return result;
  164|  2.56k|      }
  165|  2.56k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.56k|      {
   73|  2.56k|#if defined( __cpp_exceptions )
   74|  2.56k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.56k|            try {
   76|  2.56k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.56k|            }
   78|  2.56k|            catch( ... ) {
   79|  2.56k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.56k|               throw;
   81|  2.56k|            }
   82|  2.56k|         }
   83|  2.56k|         else {
   84|  2.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.56k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.56k|      {
   59|  2.56k|         return Rule::match( in );
   60|  2.56k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.11k|   {
  104|  2.11k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.11k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.11k|      }
  107|  2.11k|      else {
  108|  2.11k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.11k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.11k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.11k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.11k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.11k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.11k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.11k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.11k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.11k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.11k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.11k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.11k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.11k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.11k|         }
  128|       |
  129|  2.11k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.11k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.11k|         }
  132|       |
  133|  2.11k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.11k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.11k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.11k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.11k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.11k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.11k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.11k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70, False: 2.04k]
  ------------------
  143|     70|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|     70|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|     70|            }
  146|     70|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|     70|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|     70|            }
  149|     70|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|     70|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|     70|            }
  152|     70|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|     70|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     70|            }
  155|     70|         }
  156|  2.11k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70, False: 2.04k]
  ------------------
  157|     70|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     70|         }
  159|  2.04k|         else {
  160|  2.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.04k|         }
  162|  2.11k|         (void)m( result );
  163|  2.11k|         return result;
  164|  2.11k|      }
  165|  2.11k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.11k|      {
   73|  2.11k|#if defined( __cpp_exceptions )
   74|  2.11k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.11k|            try {
   76|  2.11k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.11k|            }
   78|  2.11k|            catch( ... ) {
   79|  2.11k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.11k|               throw;
   81|  2.11k|            }
   82|  2.11k|         }
   83|  2.11k|         else {
   84|  2.11k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.11k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.11k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.11k|      {
   59|  2.11k|         return Rule::match( in );
   60|  2.11k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.04k|   {
  104|  2.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.04k|      }
  107|  2.04k|      else {
  108|  2.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.04k|         }
  128|       |
  129|  2.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.04k|         }
  132|       |
  133|  2.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 251, False: 1.79k]
  ------------------
  143|    251|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    251|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    251|            }
  146|    251|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    251|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    251|            }
  149|    251|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    251|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    251|            }
  152|    251|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    251|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    251|            }
  155|    251|         }
  156|  2.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 251, False: 1.79k]
  ------------------
  157|    251|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    251|         }
  159|  1.79k|         else {
  160|  1.79k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.79k|         }
  162|  2.04k|         (void)m( result );
  163|  2.04k|         return result;
  164|  2.04k|      }
  165|  2.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.04k|      {
   73|  2.04k|#if defined( __cpp_exceptions )
   74|  2.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.04k|            try {
   76|  2.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.04k|            }
   78|  2.04k|            catch( ... ) {
   79|  2.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.04k|               throw;
   81|  2.04k|            }
   82|  2.04k|         }
   83|  2.04k|         else {
   84|  2.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.04k|      {
   59|  2.04k|         return Rule::match( in );
   60|  2.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.79k|   {
  104|  1.79k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.79k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.79k|      }
  107|  1.79k|      else {
  108|  1.79k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.79k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.79k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.79k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.79k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.79k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.79k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.79k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.79k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.79k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.79k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.79k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.79k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.79k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.79k|         }
  128|       |
  129|  1.79k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.79k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.79k|         }
  132|       |
  133|  1.79k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.79k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.79k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.79k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.79k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.79k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.79k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.79k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 1.59k]
  ------------------
  143|    194|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    194|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    194|            }
  146|    194|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    194|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    194|            }
  149|    194|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    194|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    194|            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  1.79k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 1.59k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  1.79k|         (void)m( result );
  163|  1.79k|         return result;
  164|  1.79k|      }
  165|  1.79k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.79k|      {
   73|  1.79k|#if defined( __cpp_exceptions )
   74|  1.79k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.79k|            try {
   76|  1.79k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.79k|            }
   78|  1.79k|            catch( ... ) {
   79|  1.79k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.79k|               throw;
   81|  1.79k|            }
   82|  1.79k|         }
   83|  1.79k|         else {
   84|  1.79k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.79k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.79k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.79k|      {
   59|  1.79k|         return Rule::match( in );
   60|  1.79k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|  3.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.04k|      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.04k|         }
  128|       |
  129|  3.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.04k|         }
  132|       |
  133|  3.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.25k, False: 792]
  ------------------
  143|  2.25k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.25k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.25k|            }
  146|  2.25k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.25k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.25k|            }
  149|  2.25k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.25k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.25k|            }
  152|  2.25k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.25k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.25k|            }
  155|  2.25k|         }
  156|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.25k, False: 792]
  ------------------
  157|  2.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.25k|         }
  159|    792|         else {
  160|    792|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    792|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.04k|#if defined( __cpp_exceptions )
   74|  3.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.04k|            try {
   76|  3.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.04k|            }
   78|  3.04k|            catch( ... ) {
   79|  3.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.04k|               throw;
   81|  3.04k|            }
   82|  3.04k|         }
   83|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.04k|      {
   59|  3.04k|         return Rule::match( in );
   60|  3.04k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.43k|   {
  104|  4.43k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.43k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.43k|      }
  107|  4.43k|      else {
  108|  4.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.43k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.43k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.43k|         }
  128|       |
  129|  4.43k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.43k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.43k|         }
  132|       |
  133|  4.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.43k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.43k, False: 0]
  ------------------
  143|  4.43k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.43k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.43k|            }
  146|  4.43k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.43k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.43k|            }
  149|  4.43k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.43k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.43k|            }
  152|  4.43k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.43k|            }
  155|  4.43k|         }
  156|  4.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.43k, False: 0]
  ------------------
  157|  4.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.43k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.43k|         (void)m( result );
  163|  4.43k|         return result;
  164|  4.43k|      }
  165|  4.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.43k|      {
   73|  4.43k|#if defined( __cpp_exceptions )
   74|  4.43k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.43k|            try {
   76|  4.43k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.43k|            }
   78|  4.43k|            catch( ... ) {
   79|  4.43k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.43k|               throw;
   81|  4.43k|            }
   82|  4.43k|         }
   83|  4.43k|         else {
   84|  4.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.43k|      {
   44|  4.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.43k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.25k|   {
  104|  2.25k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.25k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.25k|      }
  107|  2.25k|      else {
  108|  2.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.25k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.25k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.25k|         }
  128|       |
  129|  2.25k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.25k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.25k|         }
  132|       |
  133|  2.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.25k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.18k, False: 70]
  ------------------
  143|  2.18k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.18k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.18k|            }
  146|  2.18k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.18k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.18k|            }
  149|  2.18k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.18k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.18k|            }
  152|  2.18k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.18k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.18k|            }
  155|  2.18k|         }
  156|  2.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.18k, False: 70]
  ------------------
  157|  2.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.18k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|  2.25k|         (void)m( result );
  163|  2.25k|         return result;
  164|  2.25k|      }
  165|  2.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.25k|      {
   73|  2.25k|#if defined( __cpp_exceptions )
   74|  2.25k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.25k|            try {
   76|  2.25k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.25k|            }
   78|  2.25k|            catch( ... ) {
   79|  2.25k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.25k|               throw;
   81|  2.25k|            }
   82|  2.25k|         }
   83|  2.25k|         else {
   84|  2.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.25k|      {
   44|  2.25k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.25k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.19k|   {
  104|  2.19k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.19k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.19k|      }
  107|  2.19k|      else {
  108|  2.19k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.19k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.19k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  2.19k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  2.19k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  2.19k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  2.19k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  2.19k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  2.19k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.19k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.19k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.19k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.19k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  2.19k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.19k|         }
  128|       |
  129|  2.19k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  2.19k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.19k|         }
  132|       |
  133|  2.19k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.19k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.19k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.19k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  2.19k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.19k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.19k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.19k|         if( result ) {
  143|  2.19k|            if constexpr( has_apply_void ) {
  144|  2.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.19k|            }
  146|  2.19k|            else if constexpr( has_apply_bool ) {
  147|  2.19k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.19k|            }
  149|  2.19k|            else if constexpr( has_apply0_void ) {
  150|  2.19k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.19k|            }
  152|  2.19k|            else if constexpr( has_apply0_bool ) {
  153|  2.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.19k|            }
  155|  2.19k|         }
  156|  2.19k|         if( result ) {
  157|  2.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.19k|         }
  159|  2.19k|         else {
  160|  2.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.19k|         }
  162|  2.19k|         (void)m( result );
  163|  2.19k|         return result;
  164|  2.19k|      }
  165|  2.19k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.19k|      {
   44|  2.19k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.19k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.94k|   {
  104|  4.94k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.94k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.94k|      }
  107|  4.94k|      else {
  108|  4.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.94k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.94k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.94k|         }
  128|       |
  129|  4.94k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.94k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.94k|         }
  132|       |
  133|  4.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.94k|         if( result ) {
  143|  4.94k|            if constexpr( has_apply_void ) {
  144|  4.94k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.94k|            }
  146|  4.94k|            else if constexpr( has_apply_bool ) {
  147|  4.94k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.94k|            }
  149|  4.94k|            else if constexpr( has_apply0_void ) {
  150|  4.94k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.94k|            }
  152|  4.94k|            else if constexpr( has_apply0_bool ) {
  153|  4.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.94k|            }
  155|  4.94k|         }
  156|  4.94k|         if( result ) {
  157|  4.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.94k|         }
  159|  4.94k|         else {
  160|  4.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.94k|         }
  162|  4.94k|         (void)m( result );
  163|  4.94k|         return result;
  164|  4.94k|      }
  165|  4.94k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.94k|      {
   44|  4.94k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.94k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.18k|   {
  104|  2.18k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.18k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.18k|      }
  107|  2.18k|      else {
  108|  2.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.18k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.18k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.18k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.18k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.18k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.18k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.18k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.18k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.18k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.18k|         }
  128|       |
  129|  2.18k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.18k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.18k|         }
  132|       |
  133|  2.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.18k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.07k, False: 104]
  ------------------
  143|  2.07k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.07k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.07k|            }
  146|  2.07k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.07k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.07k|            }
  149|  2.07k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.07k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.07k|            }
  152|  2.07k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.07k|            }
  155|  2.07k|         }
  156|  2.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.07k, False: 104]
  ------------------
  157|  2.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.07k|         }
  159|    104|         else {
  160|    104|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    104|         }
  162|  2.18k|         (void)m( result );
  163|  2.18k|         return result;
  164|  2.18k|      }
  165|  2.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.18k|      {
   73|  2.18k|#if defined( __cpp_exceptions )
   74|  2.18k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.18k|            try {
   76|  2.18k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.18k|            }
   78|  2.18k|            catch( ... ) {
   79|  2.18k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.18k|               throw;
   81|  2.18k|            }
   82|  2.18k|         }
   83|  2.18k|         else {
   84|  2.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.18k|      {
   59|  2.18k|         return Rule::match( in );
   60|  2.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.33k|   {
  104|  6.33k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.33k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.33k|      }
  107|  6.33k|      else {
  108|  6.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.33k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.33k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.33k|         }
  128|       |
  129|  6.33k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.33k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.33k|         }
  132|       |
  133|  6.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.33k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.40k, False: 925]
  ------------------
  143|  5.40k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.40k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.40k|            }
  146|  5.40k|            else if constexpr( has_apply_bool ) {
  147|  5.40k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.40k|            }
  149|  5.40k|            else if constexpr( has_apply0_void ) {
  150|  5.40k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.40k|            }
  152|  5.40k|            else if constexpr( has_apply0_bool ) {
  153|  5.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.40k|            }
  155|  5.40k|         }
  156|  6.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.35k, False: 974]
  ------------------
  157|  5.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.35k|         }
  159|    974|         else {
  160|    974|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    974|         }
  162|  6.33k|         (void)m( result );
  163|  6.33k|         return result;
  164|  6.33k|      }
  165|  6.33k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.33k|      {
   73|  6.33k|#if defined( __cpp_exceptions )
   74|  6.33k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.33k|            try {
   76|  6.33k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.33k|            }
   78|  6.33k|            catch( ... ) {
   79|  6.33k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.33k|               throw;
   81|  6.33k|            }
   82|  6.33k|         }
   83|  6.33k|         else {
   84|  6.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.33k|      {
   44|  6.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.33k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.33k|   {
  104|  6.33k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.33k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.33k|      }
  107|  6.33k|      else {
  108|  6.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.33k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.33k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.33k|         }
  128|       |
  129|  6.33k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.33k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.33k|         }
  132|       |
  133|  6.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.33k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.65k, False: 680]
  ------------------
  143|  5.65k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.65k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.65k|            }
  146|  5.65k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.65k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.65k|            }
  149|  5.65k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.65k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.65k|            }
  152|  5.65k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.65k|            }
  155|  5.65k|         }
  156|  6.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.65k, False: 680]
  ------------------
  157|  5.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.65k|         }
  159|    680|         else {
  160|    680|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    680|         }
  162|  6.33k|         (void)m( result );
  163|  6.33k|         return result;
  164|  6.33k|      }
  165|  6.33k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.33k|      {
   73|  6.33k|#if defined( __cpp_exceptions )
   74|  6.33k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.33k|            try {
   76|  6.33k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.33k|            }
   78|  6.33k|            catch( ... ) {
   79|  6.33k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.33k|               throw;
   81|  6.33k|            }
   82|  6.33k|         }
   83|  6.33k|         else {
   84|  6.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.33k|      {
   59|  6.33k|         return Rule::match( in );
   60|  6.33k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.65k|   {
  104|  5.65k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.65k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.65k|      }
  107|  5.65k|      else {
  108|  5.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  5.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  5.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  5.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  5.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  5.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  5.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.65k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  5.65k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.65k|         }
  128|       |
  129|  5.65k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  5.65k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.65k|         }
  132|       |
  133|  5.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  5.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.65k|         if( result ) {
  143|  5.65k|            if constexpr( has_apply_void ) {
  144|  5.65k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.65k|            }
  146|  5.65k|            else if constexpr( has_apply_bool ) {
  147|  5.65k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.65k|            }
  149|  5.65k|            else if constexpr( has_apply0_void ) {
  150|  5.65k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.65k|            }
  152|  5.65k|            else if constexpr( has_apply0_bool ) {
  153|  5.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.65k|            }
  155|  5.65k|         }
  156|  5.65k|         if( result ) {
  157|  5.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.65k|         }
  159|  5.65k|         else {
  160|  5.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.65k|         }
  162|  5.65k|         (void)m( result );
  163|  5.65k|         return result;
  164|  5.65k|      }
  165|  5.65k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.65k|      {
   44|  5.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.65k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.65k|   {
  104|  5.65k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.65k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.65k|      }
  107|  5.65k|      else {
  108|  5.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.65k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.65k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.65k|         }
  128|       |
  129|  5.65k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.65k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.65k|         }
  132|       |
  133|  5.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.40k, False: 245]
  ------------------
  143|  5.40k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.40k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.40k|            }
  146|  5.40k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.40k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.40k|            }
  149|  5.40k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.40k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.40k|            }
  152|  5.40k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.40k|            }
  155|  5.40k|         }
  156|  5.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.40k, False: 245]
  ------------------
  157|  5.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.40k|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  5.65k|         (void)m( result );
  163|  5.65k|         return result;
  164|  5.65k|      }
  165|  5.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.65k|      {
   73|  5.65k|#if defined( __cpp_exceptions )
   74|  5.65k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.65k|            try {
   76|  5.65k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.65k|            }
   78|  5.65k|            catch( ... ) {
   79|  5.65k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.65k|               throw;
   81|  5.65k|            }
   82|  5.65k|         }
   83|  5.65k|         else {
   84|  5.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.65k|      {
   44|  5.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.65k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.30M|   {
  104|  6.30M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.30M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.30M|      }
  107|  6.30M|      else {
  108|  6.30M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.30M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.30M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.30M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.30M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.30M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.30M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.30M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.30M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.30M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.30M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.30M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.30M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.30M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.30M|         }
  128|       |
  129|  6.30M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.30M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.30M|         }
  132|       |
  133|  6.30M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.30M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.30M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.30M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.30M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.30M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.30M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.30M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.40k, False: 6.29M]
  ------------------
  143|  5.40k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.40k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.40k|            }
  146|  5.40k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.40k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.40k|            }
  149|  5.40k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.40k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.40k|            }
  152|  5.40k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.40k|            }
  155|  5.40k|         }
  156|  6.30M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.40k, False: 6.29M]
  ------------------
  157|  5.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.40k|         }
  159|  6.29M|         else {
  160|  6.29M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.29M|         }
  162|  6.30M|         (void)m( result );
  163|  6.30M|         return result;
  164|  6.30M|      }
  165|  6.30M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.30M|      {
   73|  6.30M|#if defined( __cpp_exceptions )
   74|  6.30M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.30M|            try {
   76|  6.30M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.30M|            }
   78|  6.30M|            catch( ... ) {
   79|  6.30M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.30M|               throw;
   81|  6.30M|            }
   82|  6.30M|         }
   83|  6.30M|         else {
   84|  6.30M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.30M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.30M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.30M|      {
   59|  6.30M|         return Rule::match( in );
   60|  6.30M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.29M|   {
  104|  6.29M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.29M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.29M|      }
  107|  6.29M|      else {
  108|  6.29M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.29M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.29M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.29M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.29M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.29M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.29M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.29M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.29M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.29M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.29M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.29M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.29M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.29M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.29M|         }
  128|       |
  129|  6.29M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.29M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.29M|         }
  132|       |
  133|  6.29M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.29M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.29M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.29M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.29M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.29M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.29M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.29M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.29M, False: 245]
  ------------------
  143|  6.29M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.29M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.29M|            }
  146|  6.29M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.29M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.29M|            }
  149|  6.29M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.29M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.29M|            }
  152|  6.29M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.29M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.29M|            }
  155|  6.29M|         }
  156|  6.29M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.29M, False: 245]
  ------------------
  157|  6.29M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.29M|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  6.29M|         (void)m( result );
  163|  6.29M|         return result;
  164|  6.29M|      }
  165|  6.29M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.29M|      {
   73|  6.29M|#if defined( __cpp_exceptions )
   74|  6.29M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.29M|            try {
   76|  6.29M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.29M|            }
   78|  6.29M|            catch( ... ) {
   79|  6.29M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.29M|               throw;
   81|  6.29M|            }
   82|  6.29M|         }
   83|  6.29M|         else {
   84|  6.29M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.29M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.29M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.29M|      {
   44|  6.29M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.29M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.29M|   {
  104|  6.29M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.29M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.29M|      }
  107|  6.29M|      else {
  108|  6.29M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.29M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.29M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.29M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.29M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.29M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.29M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.29M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.29M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.29M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.29M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.29M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.29M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.29M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.29M|         }
  128|       |
  129|  6.29M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.29M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.29M|         }
  132|       |
  133|  6.29M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.29M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.29M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.29M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.29M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.29M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.29M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.29M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.4k, False: 6.20M]
  ------------------
  143|  97.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  97.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  97.4k|            }
  146|  97.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  97.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  97.4k|            }
  149|  97.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  97.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  97.4k|            }
  152|  97.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  97.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.4k|            }
  155|  97.4k|         }
  156|  6.29M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.4k, False: 6.20M]
  ------------------
  157|  97.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.4k|         }
  159|  6.20M|         else {
  160|  6.20M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.20M|         }
  162|  6.29M|         (void)m( result );
  163|  6.29M|         return result;
  164|  6.29M|      }
  165|  6.29M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.29M|      {
   73|  6.29M|#if defined( __cpp_exceptions )
   74|  6.29M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.29M|            try {
   76|  6.29M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.29M|            }
   78|  6.29M|            catch( ... ) {
   79|  6.29M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.29M|               throw;
   81|  6.29M|            }
   82|  6.29M|         }
   83|  6.29M|         else {
   84|  6.29M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.29M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.29M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.29M|      {
   44|  6.29M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.29M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.29M|   {
  104|  6.29M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.29M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.29M|      }
  107|  6.29M|      else {
  108|  6.29M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.29M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.29M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.29M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.29M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.29M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.29M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.29M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.29M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.29M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.29M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.29M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.29M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.29M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.29M|         }
  128|       |
  129|  6.29M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.29M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.29M|         }
  132|       |
  133|  6.29M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.29M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.29M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.29M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.29M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.29M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.29M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.29M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.4k, False: 6.20M]
  ------------------
  143|  97.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  97.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  97.4k|            }
  146|  97.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  97.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  97.4k|            }
  149|  97.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  97.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  97.4k|            }
  152|  97.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  97.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.4k|            }
  155|  97.4k|         }
  156|  6.29M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.4k, False: 6.20M]
  ------------------
  157|  97.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.4k|         }
  159|  6.20M|         else {
  160|  6.20M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.20M|         }
  162|  6.29M|         (void)m( result );
  163|  6.29M|         return result;
  164|  6.29M|      }
  165|  6.29M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.29M|      {
   73|  6.29M|#if defined( __cpp_exceptions )
   74|  6.29M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.29M|            try {
   76|  6.29M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.29M|            }
   78|  6.29M|            catch( ... ) {
   79|  6.29M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.29M|               throw;
   81|  6.29M|            }
   82|  6.29M|         }
   83|  6.29M|         else {
   84|  6.29M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.29M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.29M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.29M|      {
   59|  6.29M|         return Rule::match( in );
   60|  6.29M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  97.4k|   {
  104|  97.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  97.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  97.4k|      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  97.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  97.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  97.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  97.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  97.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  97.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  97.4k|         }
  128|       |
  129|  97.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  97.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  97.4k|         }
  132|       |
  133|  97.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  143|  97.4k|            if constexpr( has_apply_void ) {
  144|  97.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  97.4k|            }
  146|  97.4k|            else if constexpr( has_apply_bool ) {
  147|  97.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  97.4k|            }
  149|  97.4k|            else if constexpr( has_apply0_void ) {
  150|  97.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  97.4k|            }
  152|  97.4k|            else if constexpr( has_apply0_bool ) {
  153|  97.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.4k|            }
  155|  97.4k|         }
  156|  97.4k|         if( result ) {
  157|  97.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.4k|         }
  159|  97.4k|         else {
  160|  97.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  97.4k|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.4k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  97.4k|      {
   44|  97.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.4k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  97.4k|   {
  104|  97.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  97.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  97.4k|      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  97.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  97.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  97.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  97.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  97.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  97.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  97.4k|         }
  128|       |
  129|  97.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  97.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  97.4k|         }
  132|       |
  133|  97.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.4k, False: 70]
  ------------------
  143|  97.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  97.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  97.4k|            }
  146|  97.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  97.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  97.4k|            }
  149|  97.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  97.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  97.4k|            }
  152|  97.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  97.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.4k|            }
  155|  97.4k|         }
  156|  97.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.4k, False: 70]
  ------------------
  157|  97.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.4k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  97.4k|      {
   73|  97.4k|#if defined( __cpp_exceptions )
   74|  97.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  97.4k|            try {
   76|  97.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  97.4k|            }
   78|  97.4k|            catch( ... ) {
   79|  97.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  97.4k|               throw;
   81|  97.4k|            }
   82|  97.4k|         }
   83|  97.4k|         else {
   84|  97.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  97.4k|      {
   44|  97.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  97.4k|   {
  104|  97.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  97.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  97.4k|      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  97.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  97.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  97.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  97.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  97.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  97.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  97.4k|         }
  128|       |
  129|  97.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  97.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  97.4k|         }
  132|       |
  133|  97.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.4k, False: 56.0k]
  ------------------
  143|  41.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  41.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  41.4k|            }
  146|  41.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  41.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  41.4k|            }
  149|  41.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  41.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  41.4k|            }
  152|  41.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  41.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.4k|            }
  155|  41.4k|         }
  156|  97.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.4k, False: 56.0k]
  ------------------
  157|  41.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.4k|         }
  159|  56.0k|         else {
  160|  56.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  56.0k|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  97.4k|      {
   73|  97.4k|#if defined( __cpp_exceptions )
   74|  97.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  97.4k|            try {
   76|  97.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  97.4k|            }
   78|  97.4k|            catch( ... ) {
   79|  97.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  97.4k|               throw;
   81|  97.4k|            }
   82|  97.4k|         }
   83|  97.4k|         else {
   84|  97.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  97.4k|      {
   44|  97.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  97.4k|   {
  104|  97.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  97.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  97.4k|      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  97.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  97.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  97.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  97.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  97.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  97.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  97.4k|         }
  128|       |
  129|  97.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  97.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  97.4k|         }
  132|       |
  133|  97.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.5k, False: 55.9k]
  ------------------
  143|  41.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  41.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  41.5k|            }
  146|  41.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  41.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  41.5k|            }
  149|  41.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  41.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  41.5k|            }
  152|  41.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  41.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.5k|            }
  155|  41.5k|         }
  156|  97.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.5k, False: 55.9k]
  ------------------
  157|  41.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.5k|         }
  159|  55.9k|         else {
  160|  55.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  55.9k|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  97.4k|      {
   73|  97.4k|#if defined( __cpp_exceptions )
   74|  97.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  97.4k|            try {
   76|  97.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  97.4k|            }
   78|  97.4k|            catch( ... ) {
   79|  97.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  97.4k|               throw;
   81|  97.4k|            }
   82|  97.4k|         }
   83|  97.4k|         else {
   84|  97.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  97.4k|      {
   59|  97.4k|         return Rule::match( in );
   60|  97.4k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  41.5k|   {
  104|  41.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  41.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  41.5k|      }
  107|  41.5k|      else {
  108|  41.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  41.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  41.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  41.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  41.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  41.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  41.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  41.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  41.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  41.5k|         }
  128|       |
  129|  41.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  41.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  41.5k|         }
  132|       |
  133|  41.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  41.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.5k|         if( result ) {
  143|  41.5k|            if constexpr( has_apply_void ) {
  144|  41.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  41.5k|            }
  146|  41.5k|            else if constexpr( has_apply_bool ) {
  147|  41.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  41.5k|            }
  149|  41.5k|            else if constexpr( has_apply0_void ) {
  150|  41.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  41.5k|            }
  152|  41.5k|            else if constexpr( has_apply0_bool ) {
  153|  41.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.5k|            }
  155|  41.5k|         }
  156|  41.5k|         if( result ) {
  157|  41.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.5k|         }
  159|  41.5k|         else {
  160|  41.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.5k|         }
  162|  41.5k|         (void)m( result );
  163|  41.5k|         return result;
  164|  41.5k|      }
  165|  41.5k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.5k|      {
   44|  41.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.5k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  41.5k|   {
  104|  41.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  41.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  41.5k|      }
  107|  41.5k|      else {
  108|  41.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  41.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  41.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  41.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  41.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  41.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  41.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  41.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  41.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  41.5k|         }
  128|       |
  129|  41.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  41.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  41.5k|         }
  132|       |
  133|  41.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  41.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.4k, False: 33]
  ------------------
  143|  41.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  41.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  41.4k|            }
  146|  41.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  41.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  41.4k|            }
  149|  41.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  41.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  41.4k|            }
  152|  41.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  41.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.4k|            }
  155|  41.4k|         }
  156|  41.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.4k, False: 33]
  ------------------
  157|  41.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.4k|         }
  159|     33|         else {
  160|     33|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     33|         }
  162|  41.5k|         (void)m( result );
  163|  41.5k|         return result;
  164|  41.5k|      }
  165|  41.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  41.5k|      {
   73|  41.5k|#if defined( __cpp_exceptions )
   74|  41.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  41.5k|            try {
   76|  41.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  41.5k|            }
   78|  41.5k|            catch( ... ) {
   79|  41.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  41.5k|               throw;
   81|  41.5k|            }
   82|  41.5k|         }
   83|  41.5k|         else {
   84|  41.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.5k|      {
   44|  41.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  82.9k|   {
  104|  82.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  82.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  82.9k|      }
  107|  82.9k|      else {
  108|  82.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  82.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  82.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  82.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  82.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  82.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  82.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  82.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  82.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  82.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  82.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  82.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  82.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  82.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  82.9k|         }
  128|       |
  129|  82.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  82.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  82.9k|         }
  132|       |
  133|  82.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  82.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  82.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  82.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  82.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  82.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  82.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  82.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 82.9k, False: 33]
  ------------------
  143|  82.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  82.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  82.9k|            }
  146|  82.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  82.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  82.9k|            }
  149|  82.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  82.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  82.9k|            }
  152|  82.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  82.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  82.9k|            }
  155|  82.9k|         }
  156|  82.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 82.9k, False: 33]
  ------------------
  157|  82.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  82.9k|         }
  159|     33|         else {
  160|     33|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     33|         }
  162|  82.9k|         (void)m( result );
  163|  82.9k|         return result;
  164|  82.9k|      }
  165|  82.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  82.9k|      {
   73|  82.9k|#if defined( __cpp_exceptions )
   74|  82.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  82.9k|            try {
   76|  82.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  82.9k|            }
   78|  82.9k|            catch( ... ) {
   79|  82.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  82.9k|               throw;
   81|  82.9k|            }
   82|  82.9k|         }
   83|  82.9k|         else {
   84|  82.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  82.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  82.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  82.9k|      {
   59|  82.9k|         return Rule::match( in );
   60|  82.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  55.9k|   {
  104|  55.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  55.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  55.9k|      }
  107|  55.9k|      else {
  108|  55.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  55.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  55.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  55.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  55.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  55.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  55.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  55.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  55.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  55.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  55.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  55.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  55.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  55.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  55.9k|         }
  128|       |
  129|  55.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  55.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  55.9k|         }
  132|       |
  133|  55.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  55.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  55.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  55.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  55.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  55.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  55.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  55.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.5k, False: 36.4k]
  ------------------
  143|  19.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  19.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  19.5k|            }
  146|  19.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  19.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  19.5k|            }
  149|  19.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  19.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  19.5k|            }
  152|  19.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  19.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.5k|            }
  155|  19.5k|         }
  156|  55.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.5k, False: 36.4k]
  ------------------
  157|  19.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.5k|         }
  159|  36.4k|         else {
  160|  36.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.4k|         }
  162|  55.9k|         (void)m( result );
  163|  55.9k|         return result;
  164|  55.9k|      }
  165|  55.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  55.9k|      {
   73|  55.9k|#if defined( __cpp_exceptions )
   74|  55.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  55.9k|            try {
   76|  55.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  55.9k|            }
   78|  55.9k|            catch( ... ) {
   79|  55.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  55.9k|               throw;
   81|  55.9k|            }
   82|  55.9k|         }
   83|  55.9k|         else {
   84|  55.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  55.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  55.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  55.9k|      {
   44|  55.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  55.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  87.1k|   {
  104|  87.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  87.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  87.1k|      }
  107|  87.1k|      else {
  108|  87.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  87.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  87.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  87.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  87.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  87.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  87.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  87.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  87.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  87.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  87.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  87.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  87.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  87.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  87.1k|         }
  128|       |
  129|  87.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  87.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  87.1k|         }
  132|       |
  133|  87.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  87.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  87.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  87.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  87.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  87.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  87.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  87.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 40.0k, False: 47.1k]
  ------------------
  143|  40.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  40.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  40.0k|            }
  146|  40.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  40.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  40.0k|            }
  149|  40.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  40.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  40.0k|            }
  152|  40.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  40.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.0k|            }
  155|  40.0k|         }
  156|  87.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.0k, False: 47.1k]
  ------------------
  157|  40.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.0k|         }
  159|  47.1k|         else {
  160|  47.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.1k|         }
  162|  87.1k|         (void)m( result );
  163|  87.1k|         return result;
  164|  87.1k|      }
  165|  87.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  87.1k|      {
   73|  87.1k|#if defined( __cpp_exceptions )
   74|  87.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  87.1k|            try {
   76|  87.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  87.1k|            }
   78|  87.1k|            catch( ... ) {
   79|  87.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  87.1k|               throw;
   81|  87.1k|            }
   82|  87.1k|         }
   83|  87.1k|         else {
   84|  87.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  87.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  87.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  87.1k|      {
   59|  87.1k|         return Rule::match( in );
   60|  87.1k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  19.5k|   {
  104|  19.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  19.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  19.5k|      }
  107|  19.5k|      else {
  108|  19.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  19.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  19.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  19.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  19.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  19.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  19.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  19.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  19.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  19.5k|         }
  128|       |
  129|  19.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  19.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  19.5k|         }
  132|       |
  133|  19.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  19.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.5k|         if( result ) {
  143|  19.5k|            if constexpr( has_apply_void ) {
  144|  19.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  19.5k|            }
  146|  19.5k|            else if constexpr( has_apply_bool ) {
  147|  19.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  19.5k|            }
  149|  19.5k|            else if constexpr( has_apply0_void ) {
  150|  19.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  19.5k|            }
  152|  19.5k|            else if constexpr( has_apply0_bool ) {
  153|  19.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.5k|            }
  155|  19.5k|         }
  156|  19.5k|         if( result ) {
  157|  19.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.5k|         }
  159|  19.5k|         else {
  160|  19.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.5k|         }
  162|  19.5k|         (void)m( result );
  163|  19.5k|         return result;
  164|  19.5k|      }
  165|  19.5k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  19.5k|      {
   44|  19.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.5k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  19.5k|   {
  104|  19.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  19.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  19.5k|      }
  107|  19.5k|      else {
  108|  19.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  19.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  19.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  19.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  19.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  19.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  19.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  19.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  19.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  19.5k|         }
  128|       |
  129|  19.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  19.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  19.5k|         }
  132|       |
  133|  19.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  19.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.5k, False: 0]
  ------------------
  143|  19.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  19.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  19.5k|            }
  146|  19.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  19.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  19.5k|            }
  149|  19.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  19.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  19.5k|            }
  152|  19.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  19.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.5k|            }
  155|  19.5k|         }
  156|  19.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.5k, False: 0]
  ------------------
  157|  19.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.5k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  19.5k|         (void)m( result );
  163|  19.5k|         return result;
  164|  19.5k|      }
  165|  19.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  19.5k|      {
   73|  19.5k|#if defined( __cpp_exceptions )
   74|  19.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  19.5k|            try {
   76|  19.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  19.5k|            }
   78|  19.5k|            catch( ... ) {
   79|  19.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  19.5k|               throw;
   81|  19.5k|            }
   82|  19.5k|         }
   83|  19.5k|         else {
   84|  19.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  19.5k|      {
   44|  19.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  36.4k|   {
  104|  36.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  36.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  36.4k|      }
  107|  36.4k|      else {
  108|  36.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  36.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  36.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  36.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  36.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  36.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  36.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  36.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  36.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  36.4k|         }
  128|       |
  129|  36.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  36.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  36.4k|         }
  132|       |
  133|  36.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  36.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  36.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.5k, False: 926]
  ------------------
  143|  35.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  35.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  35.5k|            }
  146|  35.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  35.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  35.5k|            }
  149|  35.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  35.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  35.5k|            }
  152|  35.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  35.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.5k|            }
  155|  35.5k|         }
  156|  36.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.5k, False: 926]
  ------------------
  157|  35.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.5k|         }
  159|    926|         else {
  160|    926|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    926|         }
  162|  36.4k|         (void)m( result );
  163|  36.4k|         return result;
  164|  36.4k|      }
  165|  36.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  36.4k|      {
   73|  36.4k|#if defined( __cpp_exceptions )
   74|  36.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  36.4k|            try {
   76|  36.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  36.4k|            }
   78|  36.4k|            catch( ... ) {
   79|  36.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  36.4k|               throw;
   81|  36.4k|            }
   82|  36.4k|         }
   83|  36.4k|         else {
   84|  36.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  36.4k|      {
   59|  36.4k|         return Rule::match( in );
   60|  36.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    926|   {
  104|    926|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|    926|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|    926|      }
  107|    926|      else {
  108|    926|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    926|         using iterator_t = typename ParseInput::iterator_t;
  111|    926|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|    926|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|    926|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|    926|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|    926|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|    926|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|    926|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    926|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    926|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    926|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|    926|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|    926|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|    926|         }
  128|       |
  129|    926|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|    926|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|    926|         }
  132|       |
  133|    926|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    926|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    926|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    926|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|    926|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    926|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    926|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    926|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 889, False: 37]
  ------------------
  143|    889|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    889|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    889|            }
  146|    889|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    889|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    889|            }
  149|    889|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    889|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    889|            }
  152|    889|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    889|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    889|            }
  155|    889|         }
  156|    926|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 889, False: 37]
  ------------------
  157|    889|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    889|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|    926|         (void)m( result );
  163|    926|         return result;
  164|    926|      }
  165|    926|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    926|      {
   73|    926|#if defined( __cpp_exceptions )
   74|    926|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|    926|            try {
   76|    926|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|    926|            }
   78|    926|            catch( ... ) {
   79|    926|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|    926|               throw;
   81|    926|            }
   82|    926|         }
   83|    926|         else {
   84|    926|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    926|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    926|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    926|      {
   59|    926|         return Rule::match( in );
   60|    926|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.20M|   {
  104|  6.20M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.20M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.20M|      }
  107|  6.20M|      else {
  108|  6.20M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.20M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.20M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.20M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.20M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.20M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.20M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.20M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.20M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.20M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.20M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.20M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.20M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.20M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.20M|         }
  128|       |
  129|  6.20M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.20M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.20M|         }
  132|       |
  133|  6.20M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.20M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.20M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.20M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.20M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.20M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.20M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.20M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.20M, False: 175]
  ------------------
  143|  6.20M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.20M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.20M|            }
  146|  6.20M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.20M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.20M|            }
  149|  6.20M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.20M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.20M|            }
  152|  6.20M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.20M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.20M|            }
  155|  6.20M|         }
  156|  6.20M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.20M, False: 175]
  ------------------
  157|  6.20M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.20M|         }
  159|    175|         else {
  160|    175|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    175|         }
  162|  6.20M|         (void)m( result );
  163|  6.20M|         return result;
  164|  6.20M|      }
  165|  6.20M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.20M|      {
   73|  6.20M|#if defined( __cpp_exceptions )
   74|  6.20M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.20M|            try {
   76|  6.20M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.20M|            }
   78|  6.20M|            catch( ... ) {
   79|  6.20M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.20M|               throw;
   81|  6.20M|            }
   82|  6.20M|         }
   83|  6.20M|         else {
   84|  6.20M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.20M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.20M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.20M|      {
   59|  6.20M|         return Rule::match( in );
   60|  6.20M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  30.1k|   {
  104|  30.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.1k|      }
  107|  30.1k|      else {
  108|  30.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  30.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  30.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  30.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  30.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  30.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  30.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  30.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.1k|         }
  128|       |
  129|  30.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  30.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.1k|         }
  132|       |
  133|  30.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  30.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 27.7k]
  ------------------
  143|  2.39k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.39k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.39k|            }
  146|  2.39k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.39k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.39k|            }
  149|  2.39k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.39k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.39k|            }
  152|  2.39k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.39k|            }
  155|  2.39k|         }
  156|  30.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 27.7k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  27.7k|         else {
  160|  27.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.7k|         }
  162|  30.1k|         (void)m( result );
  163|  30.1k|         return result;
  164|  30.1k|      }
  165|  30.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  30.1k|      {
   73|  30.1k|#if defined( __cpp_exceptions )
   74|  30.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  30.1k|            try {
   76|  30.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  30.1k|            }
   78|  30.1k|            catch( ... ) {
   79|  30.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  30.1k|               throw;
   81|  30.1k|            }
   82|  30.1k|         }
   83|  30.1k|         else {
   84|  30.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.1k|      {
   44|  30.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  30.1k|   {
  104|  30.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.1k|      }
  107|  30.1k|      else {
  108|  30.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  30.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  30.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  30.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  30.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  30.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  30.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  30.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.1k|         }
  128|       |
  129|  30.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  30.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.1k|         }
  132|       |
  133|  30.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  30.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 27.7k]
  ------------------
  143|  2.39k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.39k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.39k|            }
  146|  2.39k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.39k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.39k|            }
  149|  2.39k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.39k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.39k|            }
  152|  2.39k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.39k|            }
  155|  2.39k|         }
  156|  30.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 27.7k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  27.7k|         else {
  160|  27.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.7k|         }
  162|  30.1k|         (void)m( result );
  163|  30.1k|         return result;
  164|  30.1k|      }
  165|  30.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_10str_serialENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  30.1k|      {
   73|  30.1k|#if defined( __cpp_exceptions )
   74|  30.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  30.1k|            try {
   76|  30.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  30.1k|            }
   78|  30.1k|            catch( ... ) {
   79|  30.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  30.1k|               throw;
   81|  30.1k|            }
   82|  30.1k|         }
   83|  30.1k|         else {
   84|  30.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_10str_serialENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.1k|      {
   44|  30.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  30.1k|   {
  104|  30.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.1k|      }
  107|  30.1k|      else {
  108|  30.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  30.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  30.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  30.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  30.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  30.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  30.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  30.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.1k|         }
  128|       |
  129|  30.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  30.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.1k|         }
  132|       |
  133|  30.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  30.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.03k, False: 27.1k]
  ------------------
  143|  3.03k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.03k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.03k|            }
  146|  3.03k|            else if constexpr( has_apply_bool ) {
  147|  3.03k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.03k|            }
  149|  3.03k|            else if constexpr( has_apply0_void ) {
  150|  3.03k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.03k|            }
  152|  3.03k|            else if constexpr( has_apply0_bool ) {
  153|  3.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.03k|            }
  155|  3.03k|         }
  156|  30.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.03k, False: 27.1k]
  ------------------
  157|  3.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.03k|         }
  159|  27.1k|         else {
  160|  27.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.1k|         }
  162|  30.1k|         (void)m( result );
  163|  30.1k|         return result;
  164|  30.1k|      }
  165|  30.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  30.1k|      {
   73|  30.1k|#if defined( __cpp_exceptions )
   74|  30.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  30.1k|            try {
   76|  30.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  30.1k|            }
   78|  30.1k|            catch( ... ) {
   79|  30.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  30.1k|               throw;
   81|  30.1k|            }
   82|  30.1k|         }
   83|  30.1k|         else {
   84|  30.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  30.1k|      {
   59|  30.1k|         return Rule::match( in );
   60|  30.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.49k|   {
  104|  7.49k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.49k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.49k|      }
  107|  7.49k|      else {
  108|  7.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.49k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.49k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.49k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.49k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.49k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.49k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.49k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.49k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.49k|         }
  128|       |
  129|  7.49k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.49k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.49k|         }
  132|       |
  133|  7.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.41k, False: 1.07k]
  ------------------
  143|  6.41k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.41k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.41k|            }
  146|  6.41k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.41k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.41k|            }
  149|  6.41k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.41k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.41k|            }
  152|  6.41k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.41k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.41k|            }
  155|  6.41k|         }
  156|  7.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.41k, False: 1.07k]
  ------------------
  157|  6.41k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.41k|         }
  159|  1.07k|         else {
  160|  1.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.07k|         }
  162|  7.49k|         (void)m( result );
  163|  7.49k|         return result;
  164|  7.49k|      }
  165|  7.49k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  7.49k|      {
   73|  7.49k|#if defined( __cpp_exceptions )
   74|  7.49k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.49k|            try {
   76|  7.49k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.49k|            }
   78|  7.49k|            catch( ... ) {
   79|  7.49k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.49k|               throw;
   81|  7.49k|            }
   82|  7.49k|         }
   83|  7.49k|         else {
   84|  7.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.49k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.49k|      {
   44|  7.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.49k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  7.49k|   {
  104|  7.49k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.49k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.49k|      }
  107|  7.49k|      else {
  108|  7.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.49k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.49k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.49k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.49k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.49k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.49k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.49k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.49k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.49k|         }
  128|       |
  129|  7.49k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.49k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.49k|         }
  132|       |
  133|  7.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.41k, False: 1.07k]
  ------------------
  143|  6.41k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.41k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.41k|            }
  146|  6.41k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.41k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.41k|            }
  149|  6.41k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.41k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.41k|            }
  152|  6.41k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.41k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.41k|            }
  155|  6.41k|         }
  156|  7.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.41k, False: 1.07k]
  ------------------
  157|  6.41k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.41k|         }
  159|  1.07k|         else {
  160|  1.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.07k|         }
  162|  7.49k|         (void)m( result );
  163|  7.49k|         return result;
  164|  7.49k|      }
  165|  7.49k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  7.49k|      {
   73|  7.49k|#if defined( __cpp_exceptions )
   74|  7.49k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.49k|            try {
   76|  7.49k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.49k|            }
   78|  7.49k|            catch( ... ) {
   79|  7.49k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.49k|               throw;
   81|  7.49k|            }
   82|  7.49k|         }
   83|  7.49k|         else {
   84|  7.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.49k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.49k|      {
   59|  7.49k|         return Rule::match( in );
   60|  7.49k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  13.4k|   {
  104|  13.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  13.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  13.4k|      }
  107|  13.4k|      else {
  108|  13.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  13.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  13.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  13.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  13.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  13.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  13.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  13.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  13.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  13.4k|         }
  128|       |
  129|  13.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  13.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  13.4k|         }
  132|       |
  133|  13.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  13.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  13.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.63k, False: 9.81k]
  ------------------
  143|  3.63k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.63k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.63k|            }
  146|  3.63k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.63k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.63k|            }
  149|  3.63k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.63k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.63k|            }
  152|  3.63k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.63k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.63k|            }
  155|  3.63k|         }
  156|  13.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.63k, False: 9.81k]
  ------------------
  157|  3.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.63k|         }
  159|  9.81k|         else {
  160|  9.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.81k|         }
  162|  13.4k|         (void)m( result );
  163|  13.4k|         return result;
  164|  13.4k|      }
  165|  13.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  13.4k|      {
   73|  13.4k|#if defined( __cpp_exceptions )
   74|  13.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  13.4k|            try {
   76|  13.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  13.4k|            }
   78|  13.4k|            catch( ... ) {
   79|  13.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  13.4k|               throw;
   81|  13.4k|            }
   82|  13.4k|         }
   83|  13.4k|         else {
   84|  13.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  13.4k|      {
   59|  13.4k|         return Rule::match( in );
   60|  13.4k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 626]
  ------------------
  143|  2.39k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.39k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.39k|            }
  146|  2.39k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.39k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.39k|            }
  149|  2.39k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.39k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.39k|            }
  152|  2.39k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.39k|            }
  155|  2.39k|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 626]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|    626|         else {
  160|    626|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    626|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|  3.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.01k|            try {
   76|  3.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.01k|            }
   78|  3.01k|            catch( ... ) {
   79|  3.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.01k|               throw;
   81|  3.01k|            }
   82|  3.01k|         }
   83|  3.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.55k, False: 1.46k]
  ------------------
  143|  1.55k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.55k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.55k|            }
  146|  1.55k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.55k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.55k|            }
  149|  1.55k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.55k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.55k|            }
  152|  1.55k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.55k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.55k|            }
  155|  1.55k|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.55k, False: 1.46k]
  ------------------
  157|  1.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.55k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|  3.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.01k|            try {
   76|  3.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.01k|            }
   78|  3.01k|            catch( ... ) {
   79|  3.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.01k|               throw;
   81|  3.01k|            }
   82|  3.01k|         }
   83|  3.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.01k, False: 0]
  ------------------
  143|  3.01k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.01k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.01k|            }
  146|  3.01k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.01k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.01k|            }
  149|  3.01k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.01k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.01k|            }
  152|  3.01k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.01k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.01k|            }
  155|  3.01k|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.01k, False: 0]
  ------------------
  157|  3.01k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.01k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|  3.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.01k|            try {
   76|  3.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.01k|            }
   78|  3.01k|            catch( ... ) {
   79|  3.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.01k|               throw;
   81|  3.01k|            }
   82|  3.01k|         }
   83|  3.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  143|  3.01k|            if constexpr( has_apply_void ) {
  144|  3.01k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.01k|            }
  146|  3.01k|            else if constexpr( has_apply_bool ) {
  147|  3.01k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.01k|            }
  149|  3.01k|            else if constexpr( has_apply0_void ) {
  150|  3.01k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.01k|            }
  152|  3.01k|            else if constexpr( has_apply0_bool ) {
  153|  3.01k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.01k|            }
  155|  3.01k|         }
  156|  3.01k|         if( result ) {
  157|  3.01k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.01k|         }
  159|  3.01k|         else {
  160|  3.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.01k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.00k, False: 2.01k]
  ------------------
  143|  1.00k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.00k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.00k|            }
  146|  1.00k|            else if constexpr( has_apply_bool ) {
  147|  1.00k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.00k|            }
  149|  1.00k|            else if constexpr( has_apply0_void ) {
  150|  1.00k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.00k|            }
  152|  1.00k|            else if constexpr( has_apply0_bool ) {
  153|  1.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.00k|            }
  155|  1.00k|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.00k, False: 2.01k]
  ------------------
  157|  1.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.00k|         }
  159|  2.01k|         else {
  160|  2.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.01k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|  3.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.01k|            try {
   76|  3.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.01k|            }
   78|  3.01k|            catch( ... ) {
   79|  3.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.01k|               throw;
   81|  3.01k|            }
   82|  3.01k|         }
   83|  3.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 79, False: 2.94k]
  ------------------
  143|     79|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|     79|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|     79|            }
  146|     79|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|     79|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|     79|            }
  149|     79|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|     79|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|     79|            }
  152|     79|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|     79|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     79|            }
  155|     79|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 79, False: 2.94k]
  ------------------
  157|     79|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     79|         }
  159|  2.94k|         else {
  160|  2.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.94k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|  3.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.01k|            try {
   76|  3.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.01k|            }
   78|  3.01k|            catch( ... ) {
   79|  3.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.01k|               throw;
   81|  3.01k|            }
   82|  3.01k|         }
   83|  3.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.01k|      {
   59|  3.01k|         return Rule::match( in );
   60|  3.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.94k|   {
  104|  2.94k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.94k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.94k|      }
  107|  2.94k|      else {
  108|  2.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.94k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.94k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.94k|         }
  128|       |
  129|  2.94k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.94k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.94k|         }
  132|       |
  133|  2.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 286, False: 2.65k]
  ------------------
  143|    286|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    286|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    286|            }
  146|    286|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    286|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    286|            }
  149|    286|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    286|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    286|            }
  152|    286|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    286|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    286|            }
  155|    286|         }
  156|  2.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 286, False: 2.65k]
  ------------------
  157|    286|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    286|         }
  159|  2.65k|         else {
  160|  2.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.65k|         }
  162|  2.94k|         (void)m( result );
  163|  2.94k|         return result;
  164|  2.94k|      }
  165|  2.94k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.94k|      {
   73|  2.94k|#if defined( __cpp_exceptions )
   74|  2.94k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.94k|            try {
   76|  2.94k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.94k|            }
   78|  2.94k|            catch( ... ) {
   79|  2.94k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.94k|               throw;
   81|  2.94k|            }
   82|  2.94k|         }
   83|  2.94k|         else {
   84|  2.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.94k|      {
   59|  2.94k|         return Rule::match( in );
   60|  2.94k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.65k|   {
  104|  2.65k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.65k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.65k|      }
  107|  2.65k|      else {
  108|  2.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.65k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.65k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.65k|         }
  128|       |
  129|  2.65k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.65k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.65k|         }
  132|       |
  133|  2.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 202, False: 2.45k]
  ------------------
  143|    202|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    202|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    202|            }
  146|    202|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    202|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    202|            }
  149|    202|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    202|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    202|            }
  152|    202|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    202|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    202|            }
  155|    202|         }
  156|  2.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 2.45k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  2.45k|         else {
  160|  2.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45k|         }
  162|  2.65k|         (void)m( result );
  163|  2.65k|         return result;
  164|  2.65k|      }
  165|  2.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.65k|      {
   73|  2.65k|#if defined( __cpp_exceptions )
   74|  2.65k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.65k|            try {
   76|  2.65k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.65k|            }
   78|  2.65k|            catch( ... ) {
   79|  2.65k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.65k|               throw;
   81|  2.65k|            }
   82|  2.65k|         }
   83|  2.65k|         else {
   84|  2.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.65k|      {
   59|  2.65k|         return Rule::match( in );
   60|  2.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45k|   {
  104|  2.45k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.45k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.45k|      }
  107|  2.45k|      else {
  108|  2.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.45k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.45k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.45k|         }
  128|       |
  129|  2.45k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.45k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.45k|         }
  132|       |
  133|  2.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 278, False: 2.17k]
  ------------------
  143|    278|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    278|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    278|            }
  146|    278|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    278|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    278|            }
  149|    278|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    278|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    278|            }
  152|    278|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    278|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    278|            }
  155|    278|         }
  156|  2.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 278, False: 2.17k]
  ------------------
  157|    278|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    278|         }
  159|  2.17k|         else {
  160|  2.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.17k|         }
  162|  2.45k|         (void)m( result );
  163|  2.45k|         return result;
  164|  2.45k|      }
  165|  2.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.45k|      {
   73|  2.45k|#if defined( __cpp_exceptions )
   74|  2.45k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.45k|            try {
   76|  2.45k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.45k|            }
   78|  2.45k|            catch( ... ) {
   79|  2.45k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.45k|               throw;
   81|  2.45k|            }
   82|  2.45k|         }
   83|  2.45k|         else {
   84|  2.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.45k|      {
   59|  2.45k|         return Rule::match( in );
   60|  2.45k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.17k|   {
  104|  2.17k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.17k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.17k|      }
  107|  2.17k|      else {
  108|  2.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.17k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.17k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.17k|         }
  128|       |
  129|  2.17k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.17k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.17k|         }
  132|       |
  133|  2.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 128, False: 2.04k]
  ------------------
  143|    128|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    128|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    128|            }
  146|    128|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    128|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    128|            }
  149|    128|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    128|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    128|            }
  152|    128|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    128|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    128|            }
  155|    128|         }
  156|  2.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 128, False: 2.04k]
  ------------------
  157|    128|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    128|         }
  159|  2.04k|         else {
  160|  2.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.04k|         }
  162|  2.17k|         (void)m( result );
  163|  2.17k|         return result;
  164|  2.17k|      }
  165|  2.17k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.17k|      {
   73|  2.17k|#if defined( __cpp_exceptions )
   74|  2.17k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.17k|            try {
   76|  2.17k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.17k|            }
   78|  2.17k|            catch( ... ) {
   79|  2.17k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.17k|               throw;
   81|  2.17k|            }
   82|  2.17k|         }
   83|  2.17k|         else {
   84|  2.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.17k|      {
   59|  2.17k|         return Rule::match( in );
   60|  2.17k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.04k|   {
  104|  2.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.04k|      }
  107|  2.04k|      else {
  108|  2.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.04k|         }
  128|       |
  129|  2.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.04k|         }
  132|       |
  133|  2.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34, False: 2.01k]
  ------------------
  143|     34|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|     34|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|     34|            }
  146|     34|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|     34|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|     34|            }
  149|     34|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|     34|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|     34|            }
  152|     34|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|     34|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     34|            }
  155|     34|         }
  156|  2.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34, False: 2.01k]
  ------------------
  157|     34|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     34|         }
  159|  2.01k|         else {
  160|  2.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.01k|         }
  162|  2.04k|         (void)m( result );
  163|  2.04k|         return result;
  164|  2.04k|      }
  165|  2.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.04k|      {
   73|  2.04k|#if defined( __cpp_exceptions )
   74|  2.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.04k|            try {
   76|  2.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.04k|            }
   78|  2.04k|            catch( ... ) {
   79|  2.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.04k|               throw;
   81|  2.04k|            }
   82|  2.04k|         }
   83|  2.04k|         else {
   84|  2.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.04k|      {
   59|  2.04k|         return Rule::match( in );
   60|  2.04k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.01k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.01k|      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.01k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.01k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.01k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.01k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.01k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.01k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.01k|         }
  128|       |
  129|  3.01k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.01k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.01k|         }
  132|       |
  133|  3.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.72k, False: 1.29k]
  ------------------
  143|  1.72k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.72k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.72k|            }
  146|  1.72k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.72k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.72k|            }
  149|  1.72k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.72k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.72k|            }
  152|  1.72k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.72k|            }
  155|  1.72k|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.72k, False: 1.29k]
  ------------------
  157|  1.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.72k|         }
  159|  1.29k|         else {
  160|  1.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.29k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|  3.01k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.01k|            try {
   76|  3.01k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.01k|            }
   78|  3.01k|            catch( ... ) {
   79|  3.01k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.01k|               throw;
   81|  3.01k|            }
   82|  3.01k|         }
   83|  3.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.01k|      {
   59|  3.01k|         return Rule::match( in );
   60|  3.01k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.39k|   {
  104|  3.39k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.39k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.39k|      }
  107|  3.39k|      else {
  108|  3.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.39k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.39k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.39k|         }
  128|       |
  129|  3.39k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.39k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.39k|         }
  132|       |
  133|  3.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.39k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.39k, False: 0]
  ------------------
  143|  3.39k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.39k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.39k|            }
  146|  3.39k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.39k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.39k|            }
  149|  3.39k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.39k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.39k|            }
  152|  3.39k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.39k|            }
  155|  3.39k|         }
  156|  3.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.39k, False: 0]
  ------------------
  157|  3.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.39k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.39k|         (void)m( result );
  163|  3.39k|         return result;
  164|  3.39k|      }
  165|  3.39k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  3.39k|      {
   73|  3.39k|#if defined( __cpp_exceptions )
   74|  3.39k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.39k|            try {
   76|  3.39k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.39k|            }
   78|  3.39k|            catch( ... ) {
   79|  3.39k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.39k|               throw;
   81|  3.39k|            }
   82|  3.39k|         }
   83|  3.39k|         else {
   84|  3.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.39k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.39k|      {
   44|  3.39k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.39k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  1.72k|   {
  104|  1.72k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.72k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.72k|      }
  107|  1.72k|      else {
  108|  1.72k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.72k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.72k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.72k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.72k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.72k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.72k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.72k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.72k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.72k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.72k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.72k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.72k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.72k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.72k|         }
  128|       |
  129|  1.72k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.72k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.72k|         }
  132|       |
  133|  1.72k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.72k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.72k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.72k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.72k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.72k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.72k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.72k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.66k, False: 63]
  ------------------
  143|  1.66k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.66k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.66k|            }
  146|  1.66k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.66k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.66k|            }
  149|  1.66k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.66k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.66k|            }
  152|  1.66k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.66k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.66k|            }
  155|  1.66k|         }
  156|  1.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.66k, False: 63]
  ------------------
  157|  1.66k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.66k|         }
  159|     63|         else {
  160|     63|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     63|         }
  162|  1.72k|         (void)m( result );
  163|  1.72k|         return result;
  164|  1.72k|      }
  165|  1.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  1.72k|      {
   73|  1.72k|#if defined( __cpp_exceptions )
   74|  1.72k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.72k|            try {
   76|  1.72k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.72k|            }
   78|  1.72k|            catch( ... ) {
   79|  1.72k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.72k|               throw;
   81|  1.72k|            }
   82|  1.72k|         }
   83|  1.72k|         else {
   84|  1.72k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.72k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.72k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.72k|      {
   44|  1.72k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.72k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.67k|   {
  104|  1.67k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.67k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.67k|      }
  107|  1.67k|      else {
  108|  1.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.67k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  1.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  1.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  1.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  1.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  1.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  1.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.67k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.67k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  1.67k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.67k|         }
  128|       |
  129|  1.67k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  1.67k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.67k|         }
  132|       |
  133|  1.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.67k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  1.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.67k|         if( result ) {
  143|  1.67k|            if constexpr( has_apply_void ) {
  144|  1.67k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.67k|            }
  146|  1.67k|            else if constexpr( has_apply_bool ) {
  147|  1.67k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.67k|            }
  149|  1.67k|            else if constexpr( has_apply0_void ) {
  150|  1.67k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.67k|            }
  152|  1.67k|            else if constexpr( has_apply0_bool ) {
  153|  1.67k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.67k|            }
  155|  1.67k|         }
  156|  1.67k|         if( result ) {
  157|  1.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.67k|         }
  159|  1.67k|         else {
  160|  1.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.67k|         }
  162|  1.67k|         (void)m( result );
  163|  1.67k|         return result;
  164|  1.67k|      }
  165|  1.67k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.67k|      {
   44|  1.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.67k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.45k|   {
  104|  3.45k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.45k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.45k|      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.45k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.45k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.45k|         }
  128|       |
  129|  3.45k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.45k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.45k|         }
  132|       |
  133|  3.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  143|  3.45k|            if constexpr( has_apply_void ) {
  144|  3.45k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.45k|            }
  146|  3.45k|            else if constexpr( has_apply_bool ) {
  147|  3.45k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.45k|            }
  149|  3.45k|            else if constexpr( has_apply0_void ) {
  150|  3.45k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.45k|            }
  152|  3.45k|            else if constexpr( has_apply0_bool ) {
  153|  3.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.45k|            }
  155|  3.45k|         }
  156|  3.45k|         if( result ) {
  157|  3.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.45k|         }
  159|  3.45k|         else {
  160|  3.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.45k|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.45k|      {
   44|  3.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.45k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.66k|   {
  104|  1.66k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.66k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.66k|      }
  107|  1.66k|      else {
  108|  1.66k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.66k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.66k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.66k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.66k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.66k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.66k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.66k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.66k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.66k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.66k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.66k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.66k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.66k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.66k|         }
  128|       |
  129|  1.66k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.66k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.66k|         }
  132|       |
  133|  1.66k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.66k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.66k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.66k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.66k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.66k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.66k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.66k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.55k, False: 111]
  ------------------
  143|  1.55k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.55k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.55k|            }
  146|  1.55k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.55k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.55k|            }
  149|  1.55k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.55k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.55k|            }
  152|  1.55k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.55k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.55k|            }
  155|  1.55k|         }
  156|  1.66k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.55k, False: 111]
  ------------------
  157|  1.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.55k|         }
  159|    111|         else {
  160|    111|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    111|         }
  162|  1.66k|         (void)m( result );
  163|  1.66k|         return result;
  164|  1.66k|      }
  165|  1.66k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.66k|      {
   73|  1.66k|#if defined( __cpp_exceptions )
   74|  1.66k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.66k|            try {
   76|  1.66k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.66k|            }
   78|  1.66k|            catch( ... ) {
   79|  1.66k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.66k|               throw;
   81|  1.66k|            }
   82|  1.66k|         }
   83|  1.66k|         else {
   84|  1.66k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.66k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.66k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.66k|      {
   59|  1.66k|         return Rule::match( in );
   60|  1.66k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.59k|   {
  104|  5.59k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.59k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.59k|      }
  107|  5.59k|      else {
  108|  5.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.59k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.59k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.59k|         }
  128|       |
  129|  5.59k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.59k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.59k|         }
  132|       |
  133|  5.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.36k, False: 1.23k]
  ------------------
  143|  4.36k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.36k|            }
  146|  4.36k|            else if constexpr( has_apply_bool ) {
  147|  4.36k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.36k|            }
  149|  4.36k|            else if constexpr( has_apply0_void ) {
  150|  4.36k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.36k|            }
  152|  4.36k|            else if constexpr( has_apply0_bool ) {
  153|  4.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.36k|            }
  155|  4.36k|         }
  156|  5.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.29k, False: 1.29k]
  ------------------
  157|  4.29k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.29k|         }
  159|  1.29k|         else {
  160|  1.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.29k|         }
  162|  5.59k|         (void)m( result );
  163|  5.59k|         return result;
  164|  5.59k|      }
  165|  5.59k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.59k|      {
   73|  5.59k|#if defined( __cpp_exceptions )
   74|  5.59k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.59k|            try {
   76|  5.59k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.59k|            }
   78|  5.59k|            catch( ... ) {
   79|  5.59k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.59k|               throw;
   81|  5.59k|            }
   82|  5.59k|         }
   83|  5.59k|         else {
   84|  5.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.59k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.59k|      {
   44|  5.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.59k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.59k|   {
  104|  5.59k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.59k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.59k|      }
  107|  5.59k|      else {
  108|  5.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.59k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.59k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.59k|         }
  128|       |
  129|  5.59k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.59k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.59k|         }
  132|       |
  133|  5.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.64k, False: 944]
  ------------------
  143|  4.64k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.64k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.64k|            }
  146|  4.64k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.64k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.64k|            }
  149|  4.64k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.64k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.64k|            }
  152|  4.64k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.64k|            }
  155|  4.64k|         }
  156|  5.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.64k, False: 944]
  ------------------
  157|  4.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.64k|         }
  159|    944|         else {
  160|    944|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    944|         }
  162|  5.59k|         (void)m( result );
  163|  5.59k|         return result;
  164|  5.59k|      }
  165|  5.59k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.59k|      {
   73|  5.59k|#if defined( __cpp_exceptions )
   74|  5.59k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.59k|            try {
   76|  5.59k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.59k|            }
   78|  5.59k|            catch( ... ) {
   79|  5.59k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.59k|               throw;
   81|  5.59k|            }
   82|  5.59k|         }
   83|  5.59k|         else {
   84|  5.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.59k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.59k|      {
   59|  5.59k|         return Rule::match( in );
   60|  5.59k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.64k|   {
  104|  4.64k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.64k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.64k|      }
  107|  4.64k|      else {
  108|  4.64k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.64k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.64k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.64k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.64k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.64k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.64k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.64k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.64k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.64k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.64k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.64k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.64k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.64k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.64k|         }
  128|       |
  129|  4.64k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.64k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.64k|         }
  132|       |
  133|  4.64k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.64k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.64k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.64k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.64k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.64k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.64k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.64k|         if( result ) {
  143|  4.64k|            if constexpr( has_apply_void ) {
  144|  4.64k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.64k|            }
  146|  4.64k|            else if constexpr( has_apply_bool ) {
  147|  4.64k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.64k|            }
  149|  4.64k|            else if constexpr( has_apply0_void ) {
  150|  4.64k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.64k|            }
  152|  4.64k|            else if constexpr( has_apply0_bool ) {
  153|  4.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.64k|            }
  155|  4.64k|         }
  156|  4.64k|         if( result ) {
  157|  4.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.64k|         }
  159|  4.64k|         else {
  160|  4.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.64k|         }
  162|  4.64k|         (void)m( result );
  163|  4.64k|         return result;
  164|  4.64k|      }
  165|  4.64k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.64k|      {
   44|  4.64k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.64k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  4.64k|   {
  104|  4.64k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.64k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.64k|      }
  107|  4.64k|      else {
  108|  4.64k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.64k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.64k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.64k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.64k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.64k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.64k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.64k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.64k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.64k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.64k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.64k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.64k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.64k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.64k|         }
  128|       |
  129|  4.64k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.64k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.64k|         }
  132|       |
  133|  4.64k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.64k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.64k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.64k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.64k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.64k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.64k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.64k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.36k, False: 286]
  ------------------
  143|  4.36k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.36k|            }
  146|  4.36k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.36k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.36k|            }
  149|  4.36k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.36k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.36k|            }
  152|  4.36k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.36k|            }
  155|  4.36k|         }
  156|  4.64k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.36k, False: 286]
  ------------------
  157|  4.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.36k|         }
  159|    286|         else {
  160|    286|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    286|         }
  162|  4.64k|         (void)m( result );
  163|  4.64k|         return result;
  164|  4.64k|      }
  165|  4.64k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  4.64k|      {
   73|  4.64k|#if defined( __cpp_exceptions )
   74|  4.64k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.64k|            try {
   76|  4.64k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.64k|            }
   78|  4.64k|            catch( ... ) {
   79|  4.64k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.64k|               throw;
   81|  4.64k|            }
   82|  4.64k|         }
   83|  4.64k|         else {
   84|  4.64k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.64k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.64k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.64k|      {
   44|  4.64k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.64k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.35M|   {
  104|  7.35M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.35M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.35M|      }
  107|  7.35M|      else {
  108|  7.35M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.35M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.35M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.35M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.35M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.35M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.35M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.35M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.35M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.35M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.35M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.35M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.35M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.35M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.35M|         }
  128|       |
  129|  7.35M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.35M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.35M|         }
  132|       |
  133|  7.35M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.35M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.35M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.35M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.35M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.35M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.35M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.35M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.36k, False: 7.34M]
  ------------------
  143|  4.36k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.36k|            }
  146|  4.36k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.36k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.36k|            }
  149|  4.36k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.36k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.36k|            }
  152|  4.36k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.36k|            }
  155|  4.36k|         }
  156|  7.35M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.36k, False: 7.34M]
  ------------------
  157|  4.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.36k|         }
  159|  7.34M|         else {
  160|  7.34M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.34M|         }
  162|  7.35M|         (void)m( result );
  163|  7.35M|         return result;
  164|  7.35M|      }
  165|  7.35M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.35M|      {
   73|  7.35M|#if defined( __cpp_exceptions )
   74|  7.35M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.35M|            try {
   76|  7.35M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.35M|            }
   78|  7.35M|            catch( ... ) {
   79|  7.35M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.35M|               throw;
   81|  7.35M|            }
   82|  7.35M|         }
   83|  7.35M|         else {
   84|  7.35M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.35M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.35M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.35M|      {
   59|  7.35M|         return Rule::match( in );
   60|  7.35M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|  7.34M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.34M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.34M|      }
  107|  7.34M|      else {
  108|  7.34M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.34M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.34M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.34M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.34M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.34M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.34M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.34M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.34M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.34M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.34M|         }
  128|       |
  129|  7.34M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.34M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.34M|         }
  132|       |
  133|  7.34M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.34M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.34M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.34M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.34M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.34M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.34M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.34M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.34M, False: 286]
  ------------------
  143|  7.34M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.34M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.34M|            }
  146|  7.34M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.34M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.34M|            }
  149|  7.34M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.34M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.34M|            }
  152|  7.34M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.34M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.34M|            }
  155|  7.34M|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.34M, False: 286]
  ------------------
  157|  7.34M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.34M|         }
  159|    286|         else {
  160|    286|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    286|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.34M|      {
   73|  7.34M|#if defined( __cpp_exceptions )
   74|  7.34M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.34M|            try {
   76|  7.34M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.34M|            }
   78|  7.34M|            catch( ... ) {
   79|  7.34M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.34M|               throw;
   81|  7.34M|            }
   82|  7.34M|         }
   83|  7.34M|         else {
   84|  7.34M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.34M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.34M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.34M|      {
   44|  7.34M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.34M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|  7.34M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.34M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.34M|      }
  107|  7.34M|      else {
  108|  7.34M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.34M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.34M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.34M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.34M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.34M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.34M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.34M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.34M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.34M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.34M|         }
  128|       |
  129|  7.34M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.34M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.34M|         }
  132|       |
  133|  7.34M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.34M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.34M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.34M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.34M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.34M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.34M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.34M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 150k, False: 7.19M]
  ------------------
  143|   150k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   150k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   150k|            }
  146|   150k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   150k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   150k|            }
  149|   150k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   150k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   150k|            }
  152|   150k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   150k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   150k|            }
  155|   150k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 150k, False: 7.19M]
  ------------------
  157|   150k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   150k|         }
  159|  7.19M|         else {
  160|  7.19M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.19M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.34M|      {
   73|  7.34M|#if defined( __cpp_exceptions )
   74|  7.34M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.34M|            try {
   76|  7.34M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.34M|            }
   78|  7.34M|            catch( ... ) {
   79|  7.34M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.34M|               throw;
   81|  7.34M|            }
   82|  7.34M|         }
   83|  7.34M|         else {
   84|  7.34M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.34M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.34M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.34M|      {
   44|  7.34M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.34M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|  7.34M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.34M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.34M|      }
  107|  7.34M|      else {
  108|  7.34M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.34M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.34M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.34M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.34M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.34M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.34M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.34M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.34M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.34M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.34M|         }
  128|       |
  129|  7.34M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.34M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.34M|         }
  132|       |
  133|  7.34M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.34M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.34M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.34M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.34M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.34M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.34M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.34M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 151k, False: 7.19M]
  ------------------
  143|   151k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   151k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   151k|            }
  146|   151k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   151k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   151k|            }
  149|   151k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   151k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   151k|            }
  152|   151k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   151k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   151k|            }
  155|   151k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 151k, False: 7.19M]
  ------------------
  157|   151k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   151k|         }
  159|  7.19M|         else {
  160|  7.19M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.19M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.34M|      {
   73|  7.34M|#if defined( __cpp_exceptions )
   74|  7.34M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.34M|            try {
   76|  7.34M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.34M|            }
   78|  7.34M|            catch( ... ) {
   79|  7.34M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.34M|               throw;
   81|  7.34M|            }
   82|  7.34M|         }
   83|  7.34M|         else {
   84|  7.34M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.34M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.34M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.34M|      {
   59|  7.34M|         return Rule::match( in );
   60|  7.34M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   151k|   {
  104|   151k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   151k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   151k|      }
  107|   151k|      else {
  108|   151k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   151k|         using iterator_t = typename ParseInput::iterator_t;
  111|   151k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   151k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   151k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   151k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   151k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   151k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   151k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   151k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   151k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   151k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   151k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   151k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   151k|         }
  128|       |
  129|   151k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   151k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   151k|         }
  132|       |
  133|   151k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   151k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   151k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   151k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   151k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   151k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   151k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   151k|         if( result ) {
  143|   151k|            if constexpr( has_apply_void ) {
  144|   151k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   151k|            }
  146|   151k|            else if constexpr( has_apply_bool ) {
  147|   151k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   151k|            }
  149|   151k|            else if constexpr( has_apply0_void ) {
  150|   151k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   151k|            }
  152|   151k|            else if constexpr( has_apply0_bool ) {
  153|   151k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   151k|            }
  155|   151k|         }
  156|   151k|         if( result ) {
  157|   151k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   151k|         }
  159|   151k|         else {
  160|   151k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   151k|         }
  162|   151k|         (void)m( result );
  163|   151k|         return result;
  164|   151k|      }
  165|   151k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   151k|      {
   44|   151k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   151k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   151k|   {
  104|   151k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   151k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   151k|      }
  107|   151k|      else {
  108|   151k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   151k|         using iterator_t = typename ParseInput::iterator_t;
  111|   151k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   151k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   151k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   151k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   151k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   151k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   151k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   151k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   151k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   151k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   151k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   151k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   151k|         }
  128|       |
  129|   151k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   151k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   151k|         }
  132|       |
  133|   151k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   151k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   151k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   151k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   151k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   151k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   151k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   151k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 150k, False: 93]
  ------------------
  143|   150k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   150k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   150k|            }
  146|   150k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   150k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   150k|            }
  149|   150k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   150k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   150k|            }
  152|   150k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   150k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   150k|            }
  155|   150k|         }
  156|   151k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 150k, False: 93]
  ------------------
  157|   150k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   150k|         }
  159|     93|         else {
  160|     93|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     93|         }
  162|   151k|         (void)m( result );
  163|   151k|         return result;
  164|   151k|      }
  165|   151k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   151k|      {
   73|   151k|#if defined( __cpp_exceptions )
   74|   151k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   151k|            try {
   76|   151k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   151k|            }
   78|   151k|            catch( ... ) {
   79|   151k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   151k|               throw;
   81|   151k|            }
   82|   151k|         }
   83|   151k|         else {
   84|   151k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   151k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   151k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   151k|      {
   44|   151k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   151k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   151k|   {
  104|   151k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   151k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   151k|      }
  107|   151k|      else {
  108|   151k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   151k|         using iterator_t = typename ParseInput::iterator_t;
  111|   151k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   151k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   151k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   151k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   151k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   151k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   151k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   151k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   151k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   151k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   151k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   151k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   151k|         }
  128|       |
  129|   151k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   151k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   151k|         }
  132|       |
  133|   151k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   151k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   151k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   151k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   151k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   151k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   151k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   151k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.9k, False: 113k]
  ------------------
  143|  37.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  37.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  37.9k|            }
  146|  37.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  37.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  37.9k|            }
  149|  37.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  37.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  37.9k|            }
  152|  37.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  37.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.9k|            }
  155|  37.9k|         }
  156|   151k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.9k, False: 113k]
  ------------------
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|   113k|         else {
  160|   113k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   113k|         }
  162|   151k|         (void)m( result );
  163|   151k|         return result;
  164|   151k|      }
  165|   151k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   151k|      {
   73|   151k|#if defined( __cpp_exceptions )
   74|   151k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   151k|            try {
   76|   151k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   151k|            }
   78|   151k|            catch( ... ) {
   79|   151k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   151k|               throw;
   81|   151k|            }
   82|   151k|         }
   83|   151k|         else {
   84|   151k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   151k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   151k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   151k|      {
   44|   151k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   151k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   151k|   {
  104|   151k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   151k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   151k|      }
  107|   151k|      else {
  108|   151k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   151k|         using iterator_t = typename ParseInput::iterator_t;
  111|   151k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   151k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   151k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   151k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   151k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   151k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   151k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   151k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   151k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   151k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   151k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   151k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   151k|         }
  128|       |
  129|   151k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   151k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   151k|         }
  132|       |
  133|   151k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   151k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   151k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   151k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   151k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   151k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   151k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   151k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.9k, False: 113k]
  ------------------
  143|  37.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  37.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  37.9k|            }
  146|  37.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  37.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  37.9k|            }
  149|  37.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  37.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  37.9k|            }
  152|  37.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  37.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.9k|            }
  155|  37.9k|         }
  156|   151k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.9k, False: 113k]
  ------------------
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|   113k|         else {
  160|   113k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   113k|         }
  162|   151k|         (void)m( result );
  163|   151k|         return result;
  164|   151k|      }
  165|   151k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   151k|      {
   73|   151k|#if defined( __cpp_exceptions )
   74|   151k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   151k|            try {
   76|   151k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   151k|            }
   78|   151k|            catch( ... ) {
   79|   151k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   151k|               throw;
   81|   151k|            }
   82|   151k|         }
   83|   151k|         else {
   84|   151k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   151k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   151k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   151k|      {
   59|   151k|         return Rule::match( in );
   60|   151k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  37.9k|   {
  104|  37.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  37.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  37.9k|      }
  107|  37.9k|      else {
  108|  37.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  37.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  37.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  37.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  37.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  37.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  37.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  37.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  37.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  37.9k|         }
  128|       |
  129|  37.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  37.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  37.9k|         }
  132|       |
  133|  37.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  37.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.9k|         if( result ) {
  143|  37.9k|            if constexpr( has_apply_void ) {
  144|  37.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  37.9k|            }
  146|  37.9k|            else if constexpr( has_apply_bool ) {
  147|  37.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  37.9k|            }
  149|  37.9k|            else if constexpr( has_apply0_void ) {
  150|  37.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  37.9k|            }
  152|  37.9k|            else if constexpr( has_apply0_bool ) {
  153|  37.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.9k|            }
  155|  37.9k|         }
  156|  37.9k|         if( result ) {
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|  37.9k|         else {
  160|  37.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.9k|         }
  162|  37.9k|         (void)m( result );
  163|  37.9k|         return result;
  164|  37.9k|      }
  165|  37.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  37.9k|      {
   44|  37.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.9k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  37.9k|   {
  104|  37.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  37.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  37.9k|      }
  107|  37.9k|      else {
  108|  37.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  37.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  37.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  37.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  37.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  37.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  37.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  37.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  37.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  37.9k|         }
  128|       |
  129|  37.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  37.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  37.9k|         }
  132|       |
  133|  37.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  37.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.9k, False: 41]
  ------------------
  143|  37.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  37.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  37.9k|            }
  146|  37.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  37.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  37.9k|            }
  149|  37.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  37.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  37.9k|            }
  152|  37.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  37.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.9k|            }
  155|  37.9k|         }
  156|  37.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.9k, False: 41]
  ------------------
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  37.9k|         (void)m( result );
  163|  37.9k|         return result;
  164|  37.9k|      }
  165|  37.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  37.9k|      {
   73|  37.9k|#if defined( __cpp_exceptions )
   74|  37.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  37.9k|            try {
   76|  37.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  37.9k|            }
   78|  37.9k|            catch( ... ) {
   79|  37.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  37.9k|               throw;
   81|  37.9k|            }
   82|  37.9k|         }
   83|  37.9k|         else {
   84|  37.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  37.9k|      {
   44|  37.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  75.9k|   {
  104|  75.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  75.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  75.9k|      }
  107|  75.9k|      else {
  108|  75.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  75.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  75.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  75.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  75.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  75.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  75.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  75.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  75.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  75.9k|         }
  128|       |
  129|  75.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  75.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  75.9k|         }
  132|       |
  133|  75.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  75.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  75.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 75.8k, False: 41]
  ------------------
  143|  75.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  75.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  75.8k|            }
  146|  75.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  75.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  75.8k|            }
  149|  75.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  75.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  75.8k|            }
  152|  75.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  75.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  75.8k|            }
  155|  75.8k|         }
  156|  75.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 75.8k, False: 41]
  ------------------
  157|  75.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  75.8k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  75.9k|         (void)m( result );
  163|  75.9k|         return result;
  164|  75.9k|      }
  165|  75.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  75.9k|      {
   73|  75.9k|#if defined( __cpp_exceptions )
   74|  75.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  75.9k|            try {
   76|  75.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  75.9k|            }
   78|  75.9k|            catch( ... ) {
   79|  75.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  75.9k|               throw;
   81|  75.9k|            }
   82|  75.9k|         }
   83|  75.9k|         else {
   84|  75.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  75.9k|      {
   59|  75.9k|         return Rule::match( in );
   60|  75.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   113k|   {
  104|   113k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   113k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   113k|      }
  107|   113k|      else {
  108|   113k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   113k|         using iterator_t = typename ParseInput::iterator_t;
  111|   113k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   113k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   113k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   113k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   113k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   113k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   113k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   113k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   113k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   113k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   113k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   113k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   113k|         }
  128|       |
  129|   113k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   113k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   113k|         }
  132|       |
  133|   113k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   113k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   113k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   113k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   113k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   113k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   113k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   113k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.2k, False: 70.8k]
  ------------------
  143|  42.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  42.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  42.2k|            }
  146|  42.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  42.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  42.2k|            }
  149|  42.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  42.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  42.2k|            }
  152|  42.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  42.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.2k|            }
  155|  42.2k|         }
  156|   113k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.2k, False: 70.8k]
  ------------------
  157|  42.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.2k|         }
  159|  70.8k|         else {
  160|  70.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  70.8k|         }
  162|   113k|         (void)m( result );
  163|   113k|         return result;
  164|   113k|      }
  165|   113k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   113k|      {
   73|   113k|#if defined( __cpp_exceptions )
   74|   113k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   113k|            try {
   76|   113k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   113k|            }
   78|   113k|            catch( ... ) {
   79|   113k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   113k|               throw;
   81|   113k|            }
   82|   113k|         }
   83|   113k|         else {
   84|   113k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   113k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   113k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   113k|      {
   44|   113k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   113k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   173k|   {
  104|   173k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   173k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   173k|      }
  107|   173k|      else {
  108|   173k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   173k|         using iterator_t = typename ParseInput::iterator_t;
  111|   173k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   173k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   173k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   173k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   173k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   173k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   173k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   173k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   173k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   173k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   173k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   173k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   173k|         }
  128|       |
  129|   173k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   173k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   173k|         }
  132|       |
  133|   173k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   173k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   173k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   173k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   173k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   173k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   173k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   173k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70.0k, False: 103k]
  ------------------
  143|  70.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  70.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  70.0k|            }
  146|  70.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  70.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  70.0k|            }
  149|  70.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  70.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  70.0k|            }
  152|  70.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  70.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  70.0k|            }
  155|  70.0k|         }
  156|   173k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70.0k, False: 103k]
  ------------------
  157|  70.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  70.0k|         }
  159|   103k|         else {
  160|   103k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   103k|         }
  162|   173k|         (void)m( result );
  163|   173k|         return result;
  164|   173k|      }
  165|   173k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   173k|      {
   73|   173k|#if defined( __cpp_exceptions )
   74|   173k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   173k|            try {
   76|   173k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   173k|            }
   78|   173k|            catch( ... ) {
   79|   173k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   173k|               throw;
   81|   173k|            }
   82|   173k|         }
   83|   173k|         else {
   84|   173k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   173k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   173k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   173k|      {
   59|   173k|         return Rule::match( in );
   60|   173k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  42.2k|   {
  104|  42.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  42.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  42.2k|      }
  107|  42.2k|      else {
  108|  42.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  42.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  42.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  42.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  42.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  42.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  42.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  42.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  42.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  42.2k|         }
  128|       |
  129|  42.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  42.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  42.2k|         }
  132|       |
  133|  42.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  42.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  42.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.2k|         if( result ) {
  143|  42.2k|            if constexpr( has_apply_void ) {
  144|  42.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  42.2k|            }
  146|  42.2k|            else if constexpr( has_apply_bool ) {
  147|  42.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  42.2k|            }
  149|  42.2k|            else if constexpr( has_apply0_void ) {
  150|  42.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  42.2k|            }
  152|  42.2k|            else if constexpr( has_apply0_bool ) {
  153|  42.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.2k|            }
  155|  42.2k|         }
  156|  42.2k|         if( result ) {
  157|  42.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.2k|         }
  159|  42.2k|         else {
  160|  42.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  42.2k|         }
  162|  42.2k|         (void)m( result );
  163|  42.2k|         return result;
  164|  42.2k|      }
  165|  42.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  42.2k|      {
   44|  42.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.2k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  42.2k|   {
  104|  42.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  42.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  42.2k|      }
  107|  42.2k|      else {
  108|  42.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  42.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  42.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  42.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  42.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  42.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  42.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  42.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  42.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  42.2k|         }
  128|       |
  129|  42.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  42.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  42.2k|         }
  132|       |
  133|  42.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  42.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  42.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.2k, False: 0]
  ------------------
  143|  42.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  42.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  42.2k|            }
  146|  42.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  42.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  42.2k|            }
  149|  42.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  42.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  42.2k|            }
  152|  42.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  42.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.2k|            }
  155|  42.2k|         }
  156|  42.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.2k, False: 0]
  ------------------
  157|  42.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.2k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  42.2k|         (void)m( result );
  163|  42.2k|         return result;
  164|  42.2k|      }
  165|  42.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  42.2k|      {
   73|  42.2k|#if defined( __cpp_exceptions )
   74|  42.2k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  42.2k|            try {
   76|  42.2k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  42.2k|            }
   78|  42.2k|            catch( ... ) {
   79|  42.2k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  42.2k|               throw;
   81|  42.2k|            }
   82|  42.2k|         }
   83|  42.2k|         else {
   84|  42.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  42.2k|      {
   44|  42.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  70.8k|   {
  104|  70.8k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  70.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  70.8k|      }
  107|  70.8k|      else {
  108|  70.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  70.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  70.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  70.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  70.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  70.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  70.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  70.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  70.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  70.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  70.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  70.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  70.8k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  70.8k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  70.8k|         }
  128|       |
  129|  70.8k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  70.8k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  70.8k|         }
  132|       |
  133|  70.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  70.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  70.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  70.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  70.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  70.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  70.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  70.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 68.8k, False: 1.99k]
  ------------------
  143|  68.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  68.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  68.8k|            }
  146|  68.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  68.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  68.8k|            }
  149|  68.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  68.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  68.8k|            }
  152|  68.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  68.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  68.8k|            }
  155|  68.8k|         }
  156|  70.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 68.8k, False: 1.99k]
  ------------------
  157|  68.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  68.8k|         }
  159|  1.99k|         else {
  160|  1.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.99k|         }
  162|  70.8k|         (void)m( result );
  163|  70.8k|         return result;
  164|  70.8k|      }
  165|  70.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  70.8k|      {
   73|  70.8k|#if defined( __cpp_exceptions )
   74|  70.8k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  70.8k|            try {
   76|  70.8k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  70.8k|            }
   78|  70.8k|            catch( ... ) {
   79|  70.8k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  70.8k|               throw;
   81|  70.8k|            }
   82|  70.8k|         }
   83|  70.8k|         else {
   84|  70.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  70.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  70.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  70.8k|      {
   59|  70.8k|         return Rule::match( in );
   60|  70.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.99k|   {
  104|  1.99k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.99k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.99k|      }
  107|  1.99k|      else {
  108|  1.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.99k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.99k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.99k|         }
  128|       |
  129|  1.99k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.99k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.99k|         }
  132|       |
  133|  1.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.94k, False: 52]
  ------------------
  143|  1.94k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.94k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.94k|            }
  146|  1.94k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.94k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.94k|            }
  149|  1.94k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.94k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.94k|            }
  152|  1.94k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.94k|            }
  155|  1.94k|         }
  156|  1.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.94k, False: 52]
  ------------------
  157|  1.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.94k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  1.99k|         (void)m( result );
  163|  1.99k|         return result;
  164|  1.99k|      }
  165|  1.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.99k|      {
   73|  1.99k|#if defined( __cpp_exceptions )
   74|  1.99k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.99k|            try {
   76|  1.99k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.99k|            }
   78|  1.99k|            catch( ... ) {
   79|  1.99k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.99k|               throw;
   81|  1.99k|            }
   82|  1.99k|         }
   83|  1.99k|         else {
   84|  1.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.99k|      {
   59|  1.99k|         return Rule::match( in );
   60|  1.99k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.19M|   {
  104|  7.19M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.19M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.19M|      }
  107|  7.19M|      else {
  108|  7.19M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.19M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.19M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.19M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.19M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.19M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.19M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.19M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.19M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.19M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.19M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.19M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.19M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.19M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.19M|         }
  128|       |
  129|  7.19M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.19M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.19M|         }
  132|       |
  133|  7.19M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.19M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.19M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.19M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.19M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.19M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.19M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.19M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.19M, False: 193]
  ------------------
  143|  7.19M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.19M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.19M|            }
  146|  7.19M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.19M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.19M|            }
  149|  7.19M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.19M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.19M|            }
  152|  7.19M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.19M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.19M|            }
  155|  7.19M|         }
  156|  7.19M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.19M, False: 193]
  ------------------
  157|  7.19M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.19M|         }
  159|    193|         else {
  160|    193|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    193|         }
  162|  7.19M|         (void)m( result );
  163|  7.19M|         return result;
  164|  7.19M|      }
  165|  7.19M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.19M|      {
   73|  7.19M|#if defined( __cpp_exceptions )
   74|  7.19M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.19M|            try {
   76|  7.19M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.19M|            }
   78|  7.19M|            catch( ... ) {
   79|  7.19M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.19M|               throw;
   81|  7.19M|            }
   82|  7.19M|         }
   83|  7.19M|         else {
   84|  7.19M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.19M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.19M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.19M|      {
   59|  7.19M|         return Rule::match( in );
   60|  7.19M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  27.4k|   {
  104|  27.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  27.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  27.4k|      }
  107|  27.4k|      else {
  108|  27.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  27.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  27.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  27.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  27.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  27.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  27.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  27.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  27.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  27.4k|         }
  128|       |
  129|  27.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  27.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  27.4k|         }
  132|       |
  133|  27.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  27.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  27.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 24.9k]
  ------------------
  143|  2.49k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.49k|            }
  146|  2.49k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.49k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.49k|            }
  149|  2.49k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.49k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.49k|            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  27.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 24.9k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  24.9k|         else {
  160|  24.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.9k|         }
  162|  27.4k|         (void)m( result );
  163|  27.4k|         return result;
  164|  27.4k|      }
  165|  27.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  27.4k|      {
   73|  27.4k|#if defined( __cpp_exceptions )
   74|  27.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  27.4k|            try {
   76|  27.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  27.4k|            }
   78|  27.4k|            catch( ... ) {
   79|  27.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  27.4k|               throw;
   81|  27.4k|            }
   82|  27.4k|         }
   83|  27.4k|         else {
   84|  27.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  27.4k|      {
   44|  27.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  27.4k|   {
  104|  27.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  27.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  27.4k|      }
  107|  27.4k|      else {
  108|  27.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  27.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  27.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  27.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  27.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  27.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  27.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  27.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  27.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  27.4k|         }
  128|       |
  129|  27.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  27.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  27.4k|         }
  132|       |
  133|  27.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  27.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  27.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 24.9k]
  ------------------
  143|  2.49k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.49k|            }
  146|  2.49k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.49k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.49k|            }
  149|  2.49k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.49k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.49k|            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  27.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 24.9k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  24.9k|         else {
  160|  24.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.9k|         }
  162|  27.4k|         (void)m( result );
  163|  27.4k|         return result;
  164|  27.4k|      }
  165|  27.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_12str_via_portENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  27.4k|      {
   73|  27.4k|#if defined( __cpp_exceptions )
   74|  27.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  27.4k|            try {
   76|  27.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  27.4k|            }
   78|  27.4k|            catch( ... ) {
   79|  27.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  27.4k|               throw;
   81|  27.4k|            }
   82|  27.4k|         }
   83|  27.4k|         else {
   84|  27.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_12str_via_portENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  27.4k|      {
   44|  27.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  27.4k|   {
  104|  27.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  27.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  27.4k|      }
  107|  27.4k|      else {
  108|  27.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  27.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  27.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  27.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  27.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  27.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  27.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  27.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  27.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  27.4k|         }
  128|       |
  129|  27.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  27.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  27.4k|         }
  132|       |
  133|  27.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  27.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  27.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.16k, False: 24.2k]
  ------------------
  143|  3.16k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.16k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.16k|            }
  146|  3.16k|            else if constexpr( has_apply_bool ) {
  147|  3.16k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.16k|            }
  149|  3.16k|            else if constexpr( has_apply0_void ) {
  150|  3.16k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.16k|            }
  152|  3.16k|            else if constexpr( has_apply0_bool ) {
  153|  3.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.16k|            }
  155|  3.16k|         }
  156|  27.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.16k, False: 24.2k]
  ------------------
  157|  3.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.16k|         }
  159|  24.2k|         else {
  160|  24.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.2k|         }
  162|  27.4k|         (void)m( result );
  163|  27.4k|         return result;
  164|  27.4k|      }
  165|  27.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  27.4k|      {
   73|  27.4k|#if defined( __cpp_exceptions )
   74|  27.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  27.4k|            try {
   76|  27.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  27.4k|            }
   78|  27.4k|            catch( ... ) {
   79|  27.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  27.4k|               throw;
   81|  27.4k|            }
   82|  27.4k|         }
   83|  27.4k|         else {
   84|  27.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  27.4k|      {
   59|  27.4k|         return Rule::match( in );
   60|  27.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.29k|   {
  104|  8.29k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  8.29k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  8.29k|      }
  107|  8.29k|      else {
  108|  8.29k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.29k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.29k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  8.29k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  8.29k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  8.29k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  8.29k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  8.29k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  8.29k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.29k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.29k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.29k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  8.29k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  8.29k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  8.29k|         }
  128|       |
  129|  8.29k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  8.29k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  8.29k|         }
  132|       |
  133|  8.29k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.29k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.29k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.29k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  8.29k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.29k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.29k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.29k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.90k, False: 1.39k]
  ------------------
  143|  6.90k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.90k|            }
  146|  6.90k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.90k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.90k|            }
  149|  6.90k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.90k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.90k|            }
  152|  6.90k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.90k|            }
  155|  6.90k|         }
  156|  8.29k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.90k, False: 1.39k]
  ------------------
  157|  6.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.90k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  8.29k|         (void)m( result );
  163|  8.29k|         return result;
  164|  8.29k|      }
  165|  8.29k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  8.29k|      {
   73|  8.29k|#if defined( __cpp_exceptions )
   74|  8.29k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  8.29k|            try {
   76|  8.29k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  8.29k|            }
   78|  8.29k|            catch( ... ) {
   79|  8.29k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  8.29k|               throw;
   81|  8.29k|            }
   82|  8.29k|         }
   83|  8.29k|         else {
   84|  8.29k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.29k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.29k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.29k|      {
   44|  8.29k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.29k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.29k|   {
  104|  8.29k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  8.29k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  8.29k|      }
  107|  8.29k|      else {
  108|  8.29k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.29k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.29k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  8.29k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  8.29k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  8.29k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  8.29k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  8.29k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  8.29k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.29k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.29k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.29k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  8.29k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  8.29k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  8.29k|         }
  128|       |
  129|  8.29k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  8.29k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  8.29k|         }
  132|       |
  133|  8.29k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.29k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.29k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.29k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  8.29k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.29k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.29k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.29k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.90k, False: 1.39k]
  ------------------
  143|  6.90k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.90k|            }
  146|  6.90k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.90k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.90k|            }
  149|  6.90k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.90k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.90k|            }
  152|  6.90k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.90k|            }
  155|  6.90k|         }
  156|  8.29k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.90k, False: 1.39k]
  ------------------
  157|  6.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.90k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  8.29k|         (void)m( result );
  163|  8.29k|         return result;
  164|  8.29k|      }
  165|  8.29k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  8.29k|      {
   73|  8.29k|#if defined( __cpp_exceptions )
   74|  8.29k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  8.29k|            try {
   76|  8.29k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  8.29k|            }
   78|  8.29k|            catch( ... ) {
   79|  8.29k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  8.29k|               throw;
   81|  8.29k|            }
   82|  8.29k|         }
   83|  8.29k|         else {
   84|  8.29k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.29k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.29k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.29k|      {
   59|  8.29k|         return Rule::match( in );
   60|  8.29k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.4k|   {
  104|  15.4k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  15.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  15.4k|      }
  107|  15.4k|      else {
  108|  15.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  15.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  15.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  15.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  15.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  15.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  15.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  15.4k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  15.4k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  15.4k|         }
  128|       |
  129|  15.4k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  15.4k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  15.4k|         }
  132|       |
  133|  15.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  15.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  15.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.56k, False: 10.9k]
  ------------------
  143|  4.56k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.56k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.56k|            }
  146|  4.56k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.56k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.56k|            }
  149|  4.56k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.56k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.56k|            }
  152|  4.56k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.56k|            }
  155|  4.56k|         }
  156|  15.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.56k, False: 10.9k]
  ------------------
  157|  4.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.56k|         }
  159|  10.9k|         else {
  160|  10.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.9k|         }
  162|  15.4k|         (void)m( result );
  163|  15.4k|         return result;
  164|  15.4k|      }
  165|  15.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  15.4k|      {
   73|  15.4k|#if defined( __cpp_exceptions )
   74|  15.4k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  15.4k|            try {
   76|  15.4k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  15.4k|            }
   78|  15.4k|            catch( ... ) {
   79|  15.4k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  15.4k|               throw;
   81|  15.4k|            }
   82|  15.4k|         }
   83|  15.4k|         else {
   84|  15.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  15.4k|      {
   59|  15.4k|         return Rule::match( in );
   60|  15.4k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 658]
  ------------------
  143|  2.49k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.49k|            }
  146|  2.49k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.49k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.49k|            }
  149|  2.49k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.49k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.49k|            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 658]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|    658|         else {
  160|    658|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    658|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|  3.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.15k|            try {
   76|  3.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.15k|            }
   78|  3.15k|            catch( ... ) {
   79|  3.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.15k|               throw;
   81|  3.15k|            }
   82|  3.15k|         }
   83|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.87k, False: 1.28k]
  ------------------
  143|  1.87k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.87k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.87k|            }
  146|  1.87k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.87k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.87k|            }
  149|  1.87k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.87k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.87k|            }
  152|  1.87k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.87k|            }
  155|  1.87k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.87k, False: 1.28k]
  ------------------
  157|  1.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.87k|         }
  159|  1.28k|         else {
  160|  1.28k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.28k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|  3.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.15k|            try {
   76|  3.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.15k|            }
   78|  3.15k|            catch( ... ) {
   79|  3.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.15k|               throw;
   81|  3.15k|            }
   82|  3.15k|         }
   83|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.15k, False: 0]
  ------------------
  143|  3.15k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.15k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.15k|            }
  146|  3.15k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.15k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.15k|            }
  149|  3.15k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.15k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.15k|            }
  152|  3.15k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.15k|            }
  155|  3.15k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.15k, False: 0]
  ------------------
  157|  3.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.15k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|  3.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.15k|            try {
   76|  3.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.15k|            }
   78|  3.15k|            catch( ... ) {
   79|  3.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.15k|               throw;
   81|  3.15k|            }
   82|  3.15k|         }
   83|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  143|  3.15k|            if constexpr( has_apply_void ) {
  144|  3.15k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.15k|            }
  146|  3.15k|            else if constexpr( has_apply_bool ) {
  147|  3.15k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.15k|            }
  149|  3.15k|            else if constexpr( has_apply0_void ) {
  150|  3.15k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.15k|            }
  152|  3.15k|            else if constexpr( has_apply0_bool ) {
  153|  3.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.15k|            }
  155|  3.15k|         }
  156|  3.15k|         if( result ) {
  157|  3.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.15k|         }
  159|  3.15k|         else {
  160|  3.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.15k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.36k, False: 1.79k]
  ------------------
  143|  1.36k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.36k|            }
  146|  1.36k|            else if constexpr( has_apply_bool ) {
  147|  1.36k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.36k|            }
  149|  1.36k|            else if constexpr( has_apply0_void ) {
  150|  1.36k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.36k|            }
  152|  1.36k|            else if constexpr( has_apply0_bool ) {
  153|  1.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.36k|            }
  155|  1.36k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.36k, False: 1.79k]
  ------------------
  157|  1.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.36k|         }
  159|  1.79k|         else {
  160|  1.79k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.79k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|  3.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.15k|            try {
   76|  3.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.15k|            }
   78|  3.15k|            catch( ... ) {
   79|  3.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.15k|               throw;
   81|  3.15k|            }
   82|  3.15k|         }
   83|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 201, False: 2.95k]
  ------------------
  143|    201|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    201|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    201|            }
  146|    201|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    201|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    201|            }
  149|    201|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    201|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    201|            }
  152|    201|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    201|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    201|            }
  155|    201|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 201, False: 2.95k]
  ------------------
  157|    201|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    201|         }
  159|  2.95k|         else {
  160|  2.95k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.95k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|  3.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.15k|            try {
   76|  3.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.15k|            }
   78|  3.15k|            catch( ... ) {
   79|  3.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.15k|               throw;
   81|  3.15k|            }
   82|  3.15k|         }
   83|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.15k|      {
   59|  3.15k|         return Rule::match( in );
   60|  3.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.95k|   {
  104|  2.95k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.95k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.95k|      }
  107|  2.95k|      else {
  108|  2.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.95k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.95k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.95k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.95k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.95k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.95k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.95k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.95k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.95k|         }
  128|       |
  129|  2.95k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.95k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.95k|         }
  132|       |
  133|  2.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 220, False: 2.73k]
  ------------------
  143|    220|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    220|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    220|            }
  146|    220|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    220|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    220|            }
  149|    220|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    220|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    220|            }
  152|    220|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    220|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    220|            }
  155|    220|         }
  156|  2.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 220, False: 2.73k]
  ------------------
  157|    220|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    220|         }
  159|  2.73k|         else {
  160|  2.73k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.73k|         }
  162|  2.95k|         (void)m( result );
  163|  2.95k|         return result;
  164|  2.95k|      }
  165|  2.95k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.95k|      {
   73|  2.95k|#if defined( __cpp_exceptions )
   74|  2.95k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.95k|            try {
   76|  2.95k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.95k|            }
   78|  2.95k|            catch( ... ) {
   79|  2.95k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.95k|               throw;
   81|  2.95k|            }
   82|  2.95k|         }
   83|  2.95k|         else {
   84|  2.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.95k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.95k|      {
   59|  2.95k|         return Rule::match( in );
   60|  2.95k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.73k|   {
  104|  2.73k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.73k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.73k|      }
  107|  2.73k|      else {
  108|  2.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.73k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.73k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.73k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.73k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.73k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.73k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.73k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.73k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.73k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.73k|         }
  128|       |
  129|  2.73k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.73k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.73k|         }
  132|       |
  133|  2.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.73k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 211, False: 2.52k]
  ------------------
  143|    211|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    211|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    211|            }
  146|    211|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    211|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    211|            }
  149|    211|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    211|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    211|            }
  152|    211|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    211|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    211|            }
  155|    211|         }
  156|  2.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 211, False: 2.52k]
  ------------------
  157|    211|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    211|         }
  159|  2.52k|         else {
  160|  2.52k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.52k|         }
  162|  2.73k|         (void)m( result );
  163|  2.73k|         return result;
  164|  2.73k|      }
  165|  2.73k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.73k|      {
   73|  2.73k|#if defined( __cpp_exceptions )
   74|  2.73k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.73k|            try {
   76|  2.73k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.73k|            }
   78|  2.73k|            catch( ... ) {
   79|  2.73k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.73k|               throw;
   81|  2.73k|            }
   82|  2.73k|         }
   83|  2.73k|         else {
   84|  2.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.73k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.73k|      {
   59|  2.73k|         return Rule::match( in );
   60|  2.73k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.52k|   {
  104|  2.52k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.52k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.52k|      }
  107|  2.52k|      else {
  108|  2.52k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.52k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.52k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.52k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.52k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.52k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.52k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.52k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.52k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.52k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.52k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.52k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.52k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.52k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.52k|         }
  128|       |
  129|  2.52k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.52k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.52k|         }
  132|       |
  133|  2.52k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.52k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.52k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.52k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.52k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.52k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.52k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.52k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, False: 2.33k]
  ------------------
  143|    195|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    195|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    195|            }
  146|    195|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    195|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    195|            }
  149|    195|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    195|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    195|            }
  152|    195|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.33k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.33k|         else {
  160|  2.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.33k|         }
  162|  2.52k|         (void)m( result );
  163|  2.52k|         return result;
  164|  2.52k|      }
  165|  2.52k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.52k|      {
   73|  2.52k|#if defined( __cpp_exceptions )
   74|  2.52k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.52k|            try {
   76|  2.52k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.52k|            }
   78|  2.52k|            catch( ... ) {
   79|  2.52k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.52k|               throw;
   81|  2.52k|            }
   82|  2.52k|         }
   83|  2.52k|         else {
   84|  2.52k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.52k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.52k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.52k|      {
   59|  2.52k|         return Rule::match( in );
   60|  2.52k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.33k|   {
  104|  2.33k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.33k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.33k|      }
  107|  2.33k|      else {
  108|  2.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.33k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.33k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.33k|         }
  128|       |
  129|  2.33k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.33k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.33k|         }
  132|       |
  133|  2.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.33k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 338, False: 1.99k]
  ------------------
  143|    338|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    338|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    338|            }
  146|    338|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    338|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    338|            }
  149|    338|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    338|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    338|            }
  152|    338|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    338|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    338|            }
  155|    338|         }
  156|  2.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 338, False: 1.99k]
  ------------------
  157|    338|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    338|         }
  159|  1.99k|         else {
  160|  1.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.99k|         }
  162|  2.33k|         (void)m( result );
  163|  2.33k|         return result;
  164|  2.33k|      }
  165|  2.33k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.33k|      {
   73|  2.33k|#if defined( __cpp_exceptions )
   74|  2.33k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.33k|            try {
   76|  2.33k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.33k|            }
   78|  2.33k|            catch( ... ) {
   79|  2.33k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.33k|               throw;
   81|  2.33k|            }
   82|  2.33k|         }
   83|  2.33k|         else {
   84|  2.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.33k|      {
   59|  2.33k|         return Rule::match( in );
   60|  2.33k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.99k|   {
  104|  1.99k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.99k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.99k|      }
  107|  1.99k|      else {
  108|  1.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.99k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.99k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.99k|         }
  128|       |
  129|  1.99k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.99k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.99k|         }
  132|       |
  133|  1.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 201, False: 1.79k]
  ------------------
  143|    201|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    201|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    201|            }
  146|    201|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    201|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    201|            }
  149|    201|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    201|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    201|            }
  152|    201|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    201|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    201|            }
  155|    201|         }
  156|  1.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 201, False: 1.79k]
  ------------------
  157|    201|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    201|         }
  159|  1.79k|         else {
  160|  1.79k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.79k|         }
  162|  1.99k|         (void)m( result );
  163|  1.99k|         return result;
  164|  1.99k|      }
  165|  1.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.99k|      {
   73|  1.99k|#if defined( __cpp_exceptions )
   74|  1.99k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.99k|            try {
   76|  1.99k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.99k|            }
   78|  1.99k|            catch( ... ) {
   79|  1.99k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.99k|               throw;
   81|  1.99k|            }
   82|  1.99k|         }
   83|  1.99k|         else {
   84|  1.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.99k|      {
   59|  1.99k|         return Rule::match( in );
   60|  1.99k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.15k|      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.15k|         }
  128|       |
  129|  3.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.15k|         }
  132|       |
  133|  3.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.04k, False: 1.11k]
  ------------------
  143|  2.04k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.04k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.04k|            }
  146|  2.04k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.04k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.04k|            }
  149|  2.04k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.04k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.04k|            }
  152|  2.04k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.04k|            }
  155|  2.04k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.04k, False: 1.11k]
  ------------------
  157|  2.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.04k|         }
  159|  1.11k|         else {
  160|  1.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.11k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|  3.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.15k|            try {
   76|  3.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.15k|            }
   78|  3.15k|            catch( ... ) {
   79|  3.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.15k|               throw;
   81|  3.15k|            }
   82|  3.15k|         }
   83|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.15k|      {
   59|  3.15k|         return Rule::match( in );
   60|  3.15k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.02k|   {
  104|  4.02k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.02k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.02k|      }
  107|  4.02k|      else {
  108|  4.02k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.02k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.02k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.02k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.02k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.02k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.02k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.02k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.02k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.02k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.02k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.02k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.02k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.02k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.02k|         }
  128|       |
  129|  4.02k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.02k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.02k|         }
  132|       |
  133|  4.02k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.02k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.02k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.02k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.02k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.02k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.02k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.02k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.02k, False: 0]
  ------------------
  143|  4.02k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.02k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.02k|            }
  146|  4.02k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.02k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.02k|            }
  149|  4.02k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.02k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.02k|            }
  152|  4.02k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.02k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.02k|            }
  155|  4.02k|         }
  156|  4.02k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.02k, False: 0]
  ------------------
  157|  4.02k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.02k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.02k|         (void)m( result );
  163|  4.02k|         return result;
  164|  4.02k|      }
  165|  4.02k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.02k|      {
   73|  4.02k|#if defined( __cpp_exceptions )
   74|  4.02k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.02k|            try {
   76|  4.02k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.02k|            }
   78|  4.02k|            catch( ... ) {
   79|  4.02k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.02k|               throw;
   81|  4.02k|            }
   82|  4.02k|         }
   83|  4.02k|         else {
   84|  4.02k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.02k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.02k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.02k|      {
   44|  4.02k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.02k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.04k|   {
  104|  2.04k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.04k|      }
  107|  2.04k|      else {
  108|  2.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.04k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.04k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.04k|         }
  128|       |
  129|  2.04k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.04k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.04k|         }
  132|       |
  133|  2.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.98k, False: 64]
  ------------------
  143|  1.98k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.98k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.98k|            }
  146|  1.98k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.98k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.98k|            }
  149|  1.98k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.98k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.98k|            }
  152|  1.98k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.98k|            }
  155|  1.98k|         }
  156|  2.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.98k, False: 64]
  ------------------
  157|  1.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.98k|         }
  159|     64|         else {
  160|     64|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     64|         }
  162|  2.04k|         (void)m( result );
  163|  2.04k|         return result;
  164|  2.04k|      }
  165|  2.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.04k|      {
   73|  2.04k|#if defined( __cpp_exceptions )
   74|  2.04k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.04k|            try {
   76|  2.04k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.04k|            }
   78|  2.04k|            catch( ... ) {
   79|  2.04k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.04k|               throw;
   81|  2.04k|            }
   82|  2.04k|         }
   83|  2.04k|         else {
   84|  2.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.04k|      {
   44|  2.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.04k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.98k|   {
  104|  1.98k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.98k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.98k|      }
  107|  1.98k|      else {
  108|  1.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  1.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  1.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  1.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  1.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  1.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  1.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.98k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  1.98k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.98k|         }
  128|       |
  129|  1.98k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  1.98k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.98k|         }
  132|       |
  133|  1.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  1.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.98k|         if( result ) {
  143|  1.98k|            if constexpr( has_apply_void ) {
  144|  1.98k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.98k|            }
  146|  1.98k|            else if constexpr( has_apply_bool ) {
  147|  1.98k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.98k|            }
  149|  1.98k|            else if constexpr( has_apply0_void ) {
  150|  1.98k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.98k|            }
  152|  1.98k|            else if constexpr( has_apply0_bool ) {
  153|  1.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.98k|            }
  155|  1.98k|         }
  156|  1.98k|         if( result ) {
  157|  1.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.98k|         }
  159|  1.98k|         else {
  160|  1.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.98k|         }
  162|  1.98k|         (void)m( result );
  163|  1.98k|         return result;
  164|  1.98k|      }
  165|  1.98k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.98k|      {
   44|  1.98k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.98k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.76k|   {
  104|  3.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.76k|      }
  107|  3.76k|      else {
  108|  3.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.76k|         }
  128|       |
  129|  3.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.76k|         }
  132|       |
  133|  3.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.76k|         if( result ) {
  143|  3.76k|            if constexpr( has_apply_void ) {
  144|  3.76k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.76k|            }
  146|  3.76k|            else if constexpr( has_apply_bool ) {
  147|  3.76k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.76k|            }
  149|  3.76k|            else if constexpr( has_apply0_void ) {
  150|  3.76k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.76k|            }
  152|  3.76k|            else if constexpr( has_apply0_bool ) {
  153|  3.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.76k|            }
  155|  3.76k|         }
  156|  3.76k|         if( result ) {
  157|  3.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.76k|         }
  159|  3.76k|         else {
  160|  3.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.76k|         }
  162|  3.76k|         (void)m( result );
  163|  3.76k|         return result;
  164|  3.76k|      }
  165|  3.76k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.76k|      {
   44|  3.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.76k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.98k|   {
  104|  1.98k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.98k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.98k|      }
  107|  1.98k|      else {
  108|  1.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.98k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.98k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.98k|         }
  128|       |
  129|  1.98k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.98k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.98k|         }
  132|       |
  133|  1.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.98k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.87k, False: 107]
  ------------------
  143|  1.87k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.87k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.87k|            }
  146|  1.87k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.87k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.87k|            }
  149|  1.87k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.87k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.87k|            }
  152|  1.87k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.87k|            }
  155|  1.87k|         }
  156|  1.98k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.87k, False: 107]
  ------------------
  157|  1.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.87k|         }
  159|    107|         else {
  160|    107|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    107|         }
  162|  1.98k|         (void)m( result );
  163|  1.98k|         return result;
  164|  1.98k|      }
  165|  1.98k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.98k|      {
   73|  1.98k|#if defined( __cpp_exceptions )
   74|  1.98k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.98k|            try {
   76|  1.98k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.98k|            }
   78|  1.98k|            catch( ... ) {
   79|  1.98k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.98k|               throw;
   81|  1.98k|            }
   82|  1.98k|         }
   83|  1.98k|         else {
   84|  1.98k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.98k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.98k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.98k|      {
   59|  1.98k|         return Rule::match( in );
   60|  1.98k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.71k|   {
  104|  5.71k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.71k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.71k|      }
  107|  5.71k|      else {
  108|  5.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.71k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.71k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.71k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.71k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.71k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.71k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.71k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.71k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.71k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.71k|         }
  128|       |
  129|  5.71k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.71k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.71k|         }
  132|       |
  133|  5.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.71k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.45k, False: 1.25k]
  ------------------
  143|  4.45k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.45k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.45k|            }
  146|  4.45k|            else if constexpr( has_apply_bool ) {
  147|  4.45k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.45k|            }
  149|  4.45k|            else if constexpr( has_apply0_void ) {
  150|  4.45k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.45k|            }
  152|  4.45k|            else if constexpr( has_apply0_bool ) {
  153|  4.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.45k|            }
  155|  4.45k|         }
  156|  5.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.39k, False: 1.32k]
  ------------------
  157|  4.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.39k|         }
  159|  1.32k|         else {
  160|  1.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.32k|         }
  162|  5.71k|         (void)m( result );
  163|  5.71k|         return result;
  164|  5.71k|      }
  165|  5.71k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.71k|      {
   73|  5.71k|#if defined( __cpp_exceptions )
   74|  5.71k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.71k|            try {
   76|  5.71k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.71k|            }
   78|  5.71k|            catch( ... ) {
   79|  5.71k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.71k|               throw;
   81|  5.71k|            }
   82|  5.71k|         }
   83|  5.71k|         else {
   84|  5.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.71k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.71k|      {
   44|  5.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.71k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.71k|   {
  104|  5.71k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.71k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.71k|      }
  107|  5.71k|      else {
  108|  5.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.71k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.71k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.71k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.71k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.71k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.71k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.71k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.71k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.71k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.71k|         }
  128|       |
  129|  5.71k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.71k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.71k|         }
  132|       |
  133|  5.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.71k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.75k, False: 960]
  ------------------
  143|  4.75k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.75k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.75k|            }
  146|  4.75k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.75k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.75k|            }
  149|  4.75k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.75k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.75k|            }
  152|  4.75k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.75k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.75k|            }
  155|  4.75k|         }
  156|  5.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.75k, False: 960]
  ------------------
  157|  4.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.75k|         }
  159|    960|         else {
  160|    960|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    960|         }
  162|  5.71k|         (void)m( result );
  163|  5.71k|         return result;
  164|  5.71k|      }
  165|  5.71k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.71k|      {
   73|  5.71k|#if defined( __cpp_exceptions )
   74|  5.71k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.71k|            try {
   76|  5.71k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.71k|            }
   78|  5.71k|            catch( ... ) {
   79|  5.71k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.71k|               throw;
   81|  5.71k|            }
   82|  5.71k|         }
   83|  5.71k|         else {
   84|  5.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.71k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.71k|      {
   59|  5.71k|         return Rule::match( in );
   60|  5.71k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.75k|   {
  104|  4.75k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.75k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.75k|      }
  107|  4.75k|      else {
  108|  4.75k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.75k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.75k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.75k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.75k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.75k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.75k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.75k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.75k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.75k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.75k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.75k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.75k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.75k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.75k|         }
  128|       |
  129|  4.75k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.75k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.75k|         }
  132|       |
  133|  4.75k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.75k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.75k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.75k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.75k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.75k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.75k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.75k|         if( result ) {
  143|  4.75k|            if constexpr( has_apply_void ) {
  144|  4.75k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.75k|            }
  146|  4.75k|            else if constexpr( has_apply_bool ) {
  147|  4.75k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.75k|            }
  149|  4.75k|            else if constexpr( has_apply0_void ) {
  150|  4.75k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.75k|            }
  152|  4.75k|            else if constexpr( has_apply0_bool ) {
  153|  4.75k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.75k|            }
  155|  4.75k|         }
  156|  4.75k|         if( result ) {
  157|  4.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.75k|         }
  159|  4.75k|         else {
  160|  4.75k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.75k|         }
  162|  4.75k|         (void)m( result );
  163|  4.75k|         return result;
  164|  4.75k|      }
  165|  4.75k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.75k|      {
   44|  4.75k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.75k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  4.75k|   {
  104|  4.75k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.75k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.75k|      }
  107|  4.75k|      else {
  108|  4.75k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.75k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.75k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.75k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.75k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.75k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.75k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.75k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.75k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.75k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.75k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.75k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.75k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.75k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.75k|         }
  128|       |
  129|  4.75k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.75k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.75k|         }
  132|       |
  133|  4.75k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.75k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.75k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.75k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.75k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.75k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.75k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.75k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.45k, False: 298]
  ------------------
  143|  4.45k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.45k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.45k|            }
  146|  4.45k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.45k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.45k|            }
  149|  4.45k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.45k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.45k|            }
  152|  4.45k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.45k|            }
  155|  4.45k|         }
  156|  4.75k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.45k, False: 298]
  ------------------
  157|  4.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.45k|         }
  159|    298|         else {
  160|    298|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    298|         }
  162|  4.75k|         (void)m( result );
  163|  4.75k|         return result;
  164|  4.75k|      }
  165|  4.75k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  4.75k|      {
   73|  4.75k|#if defined( __cpp_exceptions )
   74|  4.75k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.75k|            try {
   76|  4.75k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.75k|            }
   78|  4.75k|            catch( ... ) {
   79|  4.75k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.75k|               throw;
   81|  4.75k|            }
   82|  4.75k|         }
   83|  4.75k|         else {
   84|  4.75k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.75k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.75k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.75k|      {
   44|  4.75k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.75k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.87M|   {
  104|  7.87M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.87M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.87M|      }
  107|  7.87M|      else {
  108|  7.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.87M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.87M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.87M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.87M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.87M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.87M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.87M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.87M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.87M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.87M|         }
  128|       |
  129|  7.87M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.87M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.87M|         }
  132|       |
  133|  7.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.87M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.45k, False: 7.87M]
  ------------------
  143|  4.45k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.45k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.45k|            }
  146|  4.45k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.45k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.45k|            }
  149|  4.45k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.45k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.45k|            }
  152|  4.45k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.45k|            }
  155|  4.45k|         }
  156|  7.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.45k, False: 7.87M]
  ------------------
  157|  4.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.45k|         }
  159|  7.87M|         else {
  160|  7.87M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.87M|         }
  162|  7.87M|         (void)m( result );
  163|  7.87M|         return result;
  164|  7.87M|      }
  165|  7.87M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.87M|      {
   73|  7.87M|#if defined( __cpp_exceptions )
   74|  7.87M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.87M|            try {
   76|  7.87M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.87M|            }
   78|  7.87M|            catch( ... ) {
   79|  7.87M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.87M|               throw;
   81|  7.87M|            }
   82|  7.87M|         }
   83|  7.87M|         else {
   84|  7.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.87M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.87M|      {
   59|  7.87M|         return Rule::match( in );
   60|  7.87M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.87M|   {
  104|  7.87M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.87M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.87M|      }
  107|  7.87M|      else {
  108|  7.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.87M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.87M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.87M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.87M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.87M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.87M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.87M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.87M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.87M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.87M|         }
  128|       |
  129|  7.87M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.87M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.87M|         }
  132|       |
  133|  7.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.87M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.87M, False: 298]
  ------------------
  143|  7.87M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.87M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.87M|            }
  146|  7.87M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.87M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.87M|            }
  149|  7.87M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.87M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.87M|            }
  152|  7.87M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.87M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.87M|            }
  155|  7.87M|         }
  156|  7.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.87M, False: 298]
  ------------------
  157|  7.87M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.87M|         }
  159|    298|         else {
  160|    298|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    298|         }
  162|  7.87M|         (void)m( result );
  163|  7.87M|         return result;
  164|  7.87M|      }
  165|  7.87M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.87M|      {
   73|  7.87M|#if defined( __cpp_exceptions )
   74|  7.87M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.87M|            try {
   76|  7.87M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.87M|            }
   78|  7.87M|            catch( ... ) {
   79|  7.87M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.87M|               throw;
   81|  7.87M|            }
   82|  7.87M|         }
   83|  7.87M|         else {
   84|  7.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.87M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.87M|      {
   44|  7.87M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.87M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.87M|   {
  104|  7.87M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.87M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.87M|      }
  107|  7.87M|      else {
  108|  7.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.87M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.87M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.87M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.87M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.87M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.87M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.87M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.87M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.87M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.87M|         }
  128|       |
  129|  7.87M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.87M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.87M|         }
  132|       |
  133|  7.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.87M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 156k, False: 7.71M]
  ------------------
  143|   156k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   156k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   156k|            }
  146|   156k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   156k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   156k|            }
  149|   156k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   156k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   156k|            }
  152|   156k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   156k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   156k|            }
  155|   156k|         }
  156|  7.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 156k, False: 7.71M]
  ------------------
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|  7.71M|         else {
  160|  7.71M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.71M|         }
  162|  7.87M|         (void)m( result );
  163|  7.87M|         return result;
  164|  7.87M|      }
  165|  7.87M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.87M|      {
   73|  7.87M|#if defined( __cpp_exceptions )
   74|  7.87M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.87M|            try {
   76|  7.87M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.87M|            }
   78|  7.87M|            catch( ... ) {
   79|  7.87M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.87M|               throw;
   81|  7.87M|            }
   82|  7.87M|         }
   83|  7.87M|         else {
   84|  7.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.87M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.87M|      {
   44|  7.87M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.87M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.87M|   {
  104|  7.87M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.87M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.87M|      }
  107|  7.87M|      else {
  108|  7.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.87M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.87M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.87M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.87M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.87M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.87M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.87M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.87M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.87M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.87M|         }
  128|       |
  129|  7.87M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.87M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.87M|         }
  132|       |
  133|  7.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.87M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 156k, False: 7.71M]
  ------------------
  143|   156k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   156k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   156k|            }
  146|   156k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   156k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   156k|            }
  149|   156k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   156k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   156k|            }
  152|   156k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   156k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   156k|            }
  155|   156k|         }
  156|  7.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 156k, False: 7.71M]
  ------------------
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|  7.71M|         else {
  160|  7.71M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.71M|         }
  162|  7.87M|         (void)m( result );
  163|  7.87M|         return result;
  164|  7.87M|      }
  165|  7.87M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.87M|      {
   73|  7.87M|#if defined( __cpp_exceptions )
   74|  7.87M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.87M|            try {
   76|  7.87M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.87M|            }
   78|  7.87M|            catch( ... ) {
   79|  7.87M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.87M|               throw;
   81|  7.87M|            }
   82|  7.87M|         }
   83|  7.87M|         else {
   84|  7.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.87M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.87M|      {
   59|  7.87M|         return Rule::match( in );
   60|  7.87M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|   156k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   156k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   156k|      }
  107|   156k|      else {
  108|   156k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   156k|         using iterator_t = typename ParseInput::iterator_t;
  111|   156k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   156k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   156k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   156k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   156k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   156k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   156k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   156k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   156k|         }
  128|       |
  129|   156k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   156k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   156k|         }
  132|       |
  133|   156k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   156k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   156k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   156k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   156k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   156k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   156k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   156k|         if( result ) {
  143|   156k|            if constexpr( has_apply_void ) {
  144|   156k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   156k|            }
  146|   156k|            else if constexpr( has_apply_bool ) {
  147|   156k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   156k|            }
  149|   156k|            else if constexpr( has_apply0_void ) {
  150|   156k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   156k|            }
  152|   156k|            else if constexpr( has_apply0_bool ) {
  153|   156k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   156k|            }
  155|   156k|         }
  156|   156k|         if( result ) {
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|   156k|         else {
  160|   156k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   156k|         }
  162|   156k|         (void)m( result );
  163|   156k|         return result;
  164|   156k|      }
  165|   156k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   156k|      {
   44|   156k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   156k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|   156k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   156k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   156k|      }
  107|   156k|      else {
  108|   156k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   156k|         using iterator_t = typename ParseInput::iterator_t;
  111|   156k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   156k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   156k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   156k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   156k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   156k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   156k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   156k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   156k|         }
  128|       |
  129|   156k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   156k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   156k|         }
  132|       |
  133|   156k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   156k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   156k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   156k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   156k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   156k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   156k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   156k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 156k, False: 101]
  ------------------
  143|   156k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   156k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   156k|            }
  146|   156k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   156k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   156k|            }
  149|   156k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   156k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   156k|            }
  152|   156k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   156k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   156k|            }
  155|   156k|         }
  156|   156k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 156k, False: 101]
  ------------------
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|    101|         else {
  160|    101|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    101|         }
  162|   156k|         (void)m( result );
  163|   156k|         return result;
  164|   156k|      }
  165|   156k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   156k|      {
   73|   156k|#if defined( __cpp_exceptions )
   74|   156k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   156k|            try {
   76|   156k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   156k|            }
   78|   156k|            catch( ... ) {
   79|   156k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   156k|               throw;
   81|   156k|            }
   82|   156k|         }
   83|   156k|         else {
   84|   156k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   156k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   156k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   156k|      {
   44|   156k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   156k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|   156k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   156k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   156k|      }
  107|   156k|      else {
  108|   156k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   156k|         using iterator_t = typename ParseInput::iterator_t;
  111|   156k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   156k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   156k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   156k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   156k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   156k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   156k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   156k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   156k|         }
  128|       |
  129|   156k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   156k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   156k|         }
  132|       |
  133|   156k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   156k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   156k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   156k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   156k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   156k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   156k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   156k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.6k, False: 128k]
  ------------------
  143|  28.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  28.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.6k|            }
  146|  28.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  28.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.6k|            }
  149|  28.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  28.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.6k|            }
  152|  28.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  28.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.6k|            }
  155|  28.6k|         }
  156|   156k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.6k, False: 128k]
  ------------------
  157|  28.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.6k|         }
  159|   128k|         else {
  160|   128k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   128k|         }
  162|   156k|         (void)m( result );
  163|   156k|         return result;
  164|   156k|      }
  165|   156k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   156k|      {
   73|   156k|#if defined( __cpp_exceptions )
   74|   156k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   156k|            try {
   76|   156k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   156k|            }
   78|   156k|            catch( ... ) {
   79|   156k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   156k|               throw;
   81|   156k|            }
   82|   156k|         }
   83|   156k|         else {
   84|   156k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   156k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   156k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   156k|      {
   44|   156k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   156k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|   156k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   156k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   156k|      }
  107|   156k|      else {
  108|   156k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   156k|         using iterator_t = typename ParseInput::iterator_t;
  111|   156k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   156k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   156k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   156k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   156k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   156k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   156k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   156k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   156k|         }
  128|       |
  129|   156k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   156k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   156k|         }
  132|       |
  133|   156k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   156k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   156k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   156k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   156k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   156k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   156k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   156k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.6k, False: 128k]
  ------------------
  143|  28.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  28.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.6k|            }
  146|  28.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  28.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.6k|            }
  149|  28.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  28.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.6k|            }
  152|  28.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  28.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.6k|            }
  155|  28.6k|         }
  156|   156k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.6k, False: 128k]
  ------------------
  157|  28.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.6k|         }
  159|   128k|         else {
  160|   128k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   128k|         }
  162|   156k|         (void)m( result );
  163|   156k|         return result;
  164|   156k|      }
  165|   156k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   156k|      {
   73|   156k|#if defined( __cpp_exceptions )
   74|   156k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   156k|            try {
   76|   156k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   156k|            }
   78|   156k|            catch( ... ) {
   79|   156k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   156k|               throw;
   81|   156k|            }
   82|   156k|         }
   83|   156k|         else {
   84|   156k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   156k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   156k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   156k|      {
   59|   156k|         return Rule::match( in );
   60|   156k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  28.6k|   {
  104|  28.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  28.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  28.6k|      }
  107|  28.6k|      else {
  108|  28.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  28.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  28.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  28.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  28.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  28.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  28.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  28.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  28.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  28.6k|         }
  128|       |
  129|  28.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  28.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  28.6k|         }
  132|       |
  133|  28.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  28.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  28.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.6k|         if( result ) {
  143|  28.6k|            if constexpr( has_apply_void ) {
  144|  28.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.6k|            }
  146|  28.6k|            else if constexpr( has_apply_bool ) {
  147|  28.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.6k|            }
  149|  28.6k|            else if constexpr( has_apply0_void ) {
  150|  28.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.6k|            }
  152|  28.6k|            else if constexpr( has_apply0_bool ) {
  153|  28.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.6k|            }
  155|  28.6k|         }
  156|  28.6k|         if( result ) {
  157|  28.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.6k|         }
  159|  28.6k|         else {
  160|  28.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.6k|         }
  162|  28.6k|         (void)m( result );
  163|  28.6k|         return result;
  164|  28.6k|      }
  165|  28.6k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  28.6k|      {
   44|  28.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.6k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  28.6k|   {
  104|  28.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  28.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  28.6k|      }
  107|  28.6k|      else {
  108|  28.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  28.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  28.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  28.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  28.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  28.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  28.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  28.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  28.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  28.6k|         }
  128|       |
  129|  28.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  28.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  28.6k|         }
  132|       |
  133|  28.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  28.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  28.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.6k, False: 49]
  ------------------
  143|  28.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  28.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.6k|            }
  146|  28.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  28.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.6k|            }
  149|  28.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  28.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.6k|            }
  152|  28.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  28.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.6k|            }
  155|  28.6k|         }
  156|  28.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.6k, False: 49]
  ------------------
  157|  28.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.6k|         }
  159|     49|         else {
  160|     49|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     49|         }
  162|  28.6k|         (void)m( result );
  163|  28.6k|         return result;
  164|  28.6k|      }
  165|  28.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  28.6k|      {
   73|  28.6k|#if defined( __cpp_exceptions )
   74|  28.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  28.6k|            try {
   76|  28.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  28.6k|            }
   78|  28.6k|            catch( ... ) {
   79|  28.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  28.6k|               throw;
   81|  28.6k|            }
   82|  28.6k|         }
   83|  28.6k|         else {
   84|  28.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  28.6k|      {
   44|  28.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  57.2k|   {
  104|  57.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  57.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  57.2k|      }
  107|  57.2k|      else {
  108|  57.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  57.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  57.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  57.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  57.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  57.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  57.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  57.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  57.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  57.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  57.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  57.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  57.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  57.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  57.2k|         }
  128|       |
  129|  57.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  57.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  57.2k|         }
  132|       |
  133|  57.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  57.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  57.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  57.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  57.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  57.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  57.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  57.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 57.2k, False: 49]
  ------------------
  143|  57.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  57.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  57.2k|            }
  146|  57.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  57.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  57.2k|            }
  149|  57.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  57.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  57.2k|            }
  152|  57.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  57.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  57.2k|            }
  155|  57.2k|         }
  156|  57.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 57.2k, False: 49]
  ------------------
  157|  57.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  57.2k|         }
  159|     49|         else {
  160|     49|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     49|         }
  162|  57.2k|         (void)m( result );
  163|  57.2k|         return result;
  164|  57.2k|      }
  165|  57.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  57.2k|      {
   73|  57.2k|#if defined( __cpp_exceptions )
   74|  57.2k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  57.2k|            try {
   76|  57.2k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  57.2k|            }
   78|  57.2k|            catch( ... ) {
   79|  57.2k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  57.2k|               throw;
   81|  57.2k|            }
   82|  57.2k|         }
   83|  57.2k|         else {
   84|  57.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  57.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  57.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  57.2k|      {
   59|  57.2k|         return Rule::match( in );
   60|  57.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   128k|   {
  104|   128k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   128k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   128k|      }
  107|   128k|      else {
  108|   128k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   128k|         using iterator_t = typename ParseInput::iterator_t;
  111|   128k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   128k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   128k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   128k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   128k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   128k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   128k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   128k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   128k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   128k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   128k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   128k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   128k|         }
  128|       |
  129|   128k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   128k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   128k|         }
  132|       |
  133|   128k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   128k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   128k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   128k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   128k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   128k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   128k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   128k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 47.2k, False: 80.8k]
  ------------------
  143|  47.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  47.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.2k|            }
  146|  47.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  47.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.2k|            }
  149|  47.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  47.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.2k|            }
  152|  47.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  47.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.2k|            }
  155|  47.2k|         }
  156|   128k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 47.2k, False: 80.8k]
  ------------------
  157|  47.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.2k|         }
  159|  80.8k|         else {
  160|  80.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  80.8k|         }
  162|   128k|         (void)m( result );
  163|   128k|         return result;
  164|   128k|      }
  165|   128k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   128k|      {
   73|   128k|#if defined( __cpp_exceptions )
   74|   128k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   128k|            try {
   76|   128k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   128k|            }
   78|   128k|            catch( ... ) {
   79|   128k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   128k|               throw;
   81|   128k|            }
   82|   128k|         }
   83|   128k|         else {
   84|   128k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   128k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   128k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   128k|      {
   44|   128k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   128k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   192k|   {
  104|   192k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   192k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   192k|      }
  107|   192k|      else {
  108|   192k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   192k|         using iterator_t = typename ParseInput::iterator_t;
  111|   192k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   192k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   192k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   192k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   192k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   192k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   192k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   192k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   192k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   192k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   192k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   192k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   192k|         }
  128|       |
  129|   192k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   192k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   192k|         }
  132|       |
  133|   192k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   192k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   192k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   192k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   192k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   192k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   192k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   192k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 73.6k, False: 118k]
  ------------------
  143|  73.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  73.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  73.6k|            }
  146|  73.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  73.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  73.6k|            }
  149|  73.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  73.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  73.6k|            }
  152|  73.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  73.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  73.6k|            }
  155|  73.6k|         }
  156|   192k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 73.6k, False: 118k]
  ------------------
  157|  73.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  73.6k|         }
  159|   118k|         else {
  160|   118k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   118k|         }
  162|   192k|         (void)m( result );
  163|   192k|         return result;
  164|   192k|      }
  165|   192k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   192k|      {
   73|   192k|#if defined( __cpp_exceptions )
   74|   192k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   192k|            try {
   76|   192k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   192k|            }
   78|   192k|            catch( ... ) {
   79|   192k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   192k|               throw;
   81|   192k|            }
   82|   192k|         }
   83|   192k|         else {
   84|   192k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   192k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   192k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   192k|      {
   59|   192k|         return Rule::match( in );
   60|   192k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  47.2k|   {
  104|  47.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.2k|      }
  107|  47.2k|      else {
  108|  47.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  47.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  47.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  47.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  47.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  47.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  47.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  47.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.2k|         }
  128|       |
  129|  47.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  47.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.2k|         }
  132|       |
  133|  47.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  47.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.2k|         if( result ) {
  143|  47.2k|            if constexpr( has_apply_void ) {
  144|  47.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.2k|            }
  146|  47.2k|            else if constexpr( has_apply_bool ) {
  147|  47.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.2k|            }
  149|  47.2k|            else if constexpr( has_apply0_void ) {
  150|  47.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.2k|            }
  152|  47.2k|            else if constexpr( has_apply0_bool ) {
  153|  47.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.2k|            }
  155|  47.2k|         }
  156|  47.2k|         if( result ) {
  157|  47.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.2k|         }
  159|  47.2k|         else {
  160|  47.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.2k|         }
  162|  47.2k|         (void)m( result );
  163|  47.2k|         return result;
  164|  47.2k|      }
  165|  47.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.2k|      {
   44|  47.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.2k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  47.2k|   {
  104|  47.2k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  47.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  47.2k|      }
  107|  47.2k|      else {
  108|  47.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  47.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  47.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  47.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  47.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  47.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  47.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  47.2k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  47.2k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  47.2k|         }
  128|       |
  129|  47.2k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  47.2k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  47.2k|         }
  132|       |
  133|  47.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  47.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  47.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 47.2k, False: 0]
  ------------------
  143|  47.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  47.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  47.2k|            }
  146|  47.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  47.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  47.2k|            }
  149|  47.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  47.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  47.2k|            }
  152|  47.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  47.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.2k|            }
  155|  47.2k|         }
  156|  47.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 47.2k, False: 0]
  ------------------
  157|  47.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.2k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  47.2k|         (void)m( result );
  163|  47.2k|         return result;
  164|  47.2k|      }
  165|  47.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  47.2k|      {
   73|  47.2k|#if defined( __cpp_exceptions )
   74|  47.2k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  47.2k|            try {
   76|  47.2k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  47.2k|            }
   78|  47.2k|            catch( ... ) {
   79|  47.2k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  47.2k|               throw;
   81|  47.2k|            }
   82|  47.2k|         }
   83|  47.2k|         else {
   84|  47.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  47.2k|      {
   44|  47.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  80.8k|   {
  104|  80.8k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  80.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  80.8k|      }
  107|  80.8k|      else {
  108|  80.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  80.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  80.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  80.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  80.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  80.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  80.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  80.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  80.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  80.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  80.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  80.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  80.8k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  80.8k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  80.8k|         }
  128|       |
  129|  80.8k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  80.8k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  80.8k|         }
  132|       |
  133|  80.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  80.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  80.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  80.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  80.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  80.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  80.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  80.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 79.1k, False: 1.70k]
  ------------------
  143|  79.1k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  79.1k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  79.1k|            }
  146|  79.1k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  79.1k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  79.1k|            }
  149|  79.1k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  79.1k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  79.1k|            }
  152|  79.1k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  79.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  79.1k|            }
  155|  79.1k|         }
  156|  80.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 79.1k, False: 1.70k]
  ------------------
  157|  79.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  79.1k|         }
  159|  1.70k|         else {
  160|  1.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70k|         }
  162|  80.8k|         (void)m( result );
  163|  80.8k|         return result;
  164|  80.8k|      }
  165|  80.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  80.8k|      {
   73|  80.8k|#if defined( __cpp_exceptions )
   74|  80.8k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  80.8k|            try {
   76|  80.8k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  80.8k|            }
   78|  80.8k|            catch( ... ) {
   79|  80.8k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  80.8k|               throw;
   81|  80.8k|            }
   82|  80.8k|         }
   83|  80.8k|         else {
   84|  80.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  80.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  80.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  80.8k|      {
   59|  80.8k|         return Rule::match( in );
   60|  80.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.70k|   {
  104|  1.70k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.70k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.70k|      }
  107|  1.70k|      else {
  108|  1.70k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.70k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.70k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.70k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.70k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.70k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.70k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.70k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.70k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.70k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.70k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.70k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.70k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.70k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.70k|         }
  128|       |
  129|  1.70k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.70k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.70k|         }
  132|       |
  133|  1.70k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.70k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.70k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.70k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.70k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.70k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.70k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.70k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.65k, False: 52]
  ------------------
  143|  1.65k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.65k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.65k|            }
  146|  1.65k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.65k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.65k|            }
  149|  1.65k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.65k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.65k|            }
  152|  1.65k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.65k|            }
  155|  1.65k|         }
  156|  1.70k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.65k, False: 52]
  ------------------
  157|  1.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.65k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  1.70k|         (void)m( result );
  163|  1.70k|         return result;
  164|  1.70k|      }
  165|  1.70k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.70k|      {
   73|  1.70k|#if defined( __cpp_exceptions )
   74|  1.70k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.70k|            try {
   76|  1.70k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.70k|            }
   78|  1.70k|            catch( ... ) {
   79|  1.70k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.70k|               throw;
   81|  1.70k|            }
   82|  1.70k|         }
   83|  1.70k|         else {
   84|  1.70k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.70k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.70k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.70k|      {
   59|  1.70k|         return Rule::match( in );
   60|  1.70k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.71M|   {
  104|  7.71M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.71M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.71M|      }
  107|  7.71M|      else {
  108|  7.71M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.71M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.71M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.71M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.71M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.71M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.71M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.71M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.71M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.71M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.71M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.71M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.71M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.71M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.71M|         }
  128|       |
  129|  7.71M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.71M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.71M|         }
  132|       |
  133|  7.71M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.71M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.71M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.71M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.71M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.71M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.71M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.71M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.71M, False: 197]
  ------------------
  143|  7.71M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.71M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.71M|            }
  146|  7.71M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.71M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.71M|            }
  149|  7.71M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.71M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.71M|            }
  152|  7.71M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.71M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.71M|            }
  155|  7.71M|         }
  156|  7.71M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.71M, False: 197]
  ------------------
  157|  7.71M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.71M|         }
  159|    197|         else {
  160|    197|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    197|         }
  162|  7.71M|         (void)m( result );
  163|  7.71M|         return result;
  164|  7.71M|      }
  165|  7.71M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.71M|      {
   73|  7.71M|#if defined( __cpp_exceptions )
   74|  7.71M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.71M|            try {
   76|  7.71M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.71M|            }
   78|  7.71M|            catch( ... ) {
   79|  7.71M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.71M|               throw;
   81|  7.71M|            }
   82|  7.71M|         }
   83|  7.71M|         else {
   84|  7.71M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.71M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.71M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.71M|      {
   59|  7.71M|         return Rule::match( in );
   60|  7.71M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  24.5k|   {
  104|  24.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  24.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  24.5k|      }
  107|  24.5k|      else {
  108|  24.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  24.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  24.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  24.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  24.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  24.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  24.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  24.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  24.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  24.5k|         }
  128|       |
  129|  24.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  24.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  24.5k|         }
  132|       |
  133|  24.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  24.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  24.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.16k, False: 21.3k]
  ------------------
  143|  3.16k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.16k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.16k|            }
  146|  3.16k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.16k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.16k|            }
  149|  3.16k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.16k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.16k|            }
  152|  3.16k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.16k|            }
  155|  3.16k|         }
  156|  24.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.16k, False: 21.3k]
  ------------------
  157|  3.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.16k|         }
  159|  21.3k|         else {
  160|  21.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.3k|         }
  162|  24.5k|         (void)m( result );
  163|  24.5k|         return result;
  164|  24.5k|      }
  165|  24.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  24.5k|      {
   73|  24.5k|#if defined( __cpp_exceptions )
   74|  24.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  24.5k|            try {
   76|  24.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  24.5k|            }
   78|  24.5k|            catch( ... ) {
   79|  24.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  24.5k|               throw;
   81|  24.5k|            }
   82|  24.5k|         }
   83|  24.5k|         else {
   84|  24.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  24.5k|      {
   44|  24.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  24.5k|   {
  104|  24.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  24.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  24.5k|      }
  107|  24.5k|      else {
  108|  24.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  24.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  24.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  24.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  24.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  24.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  24.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  24.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  24.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  24.5k|         }
  128|       |
  129|  24.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  24.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  24.5k|         }
  132|       |
  133|  24.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  24.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  24.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.16k, False: 21.3k]
  ------------------
  143|  3.16k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.16k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.16k|            }
  146|  3.16k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.16k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.16k|            }
  149|  3.16k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.16k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.16k|            }
  152|  3.16k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.16k|            }
  155|  3.16k|         }
  156|  24.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.16k, False: 21.3k]
  ------------------
  157|  3.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.16k|         }
  159|  21.3k|         else {
  160|  21.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.3k|         }
  162|  24.5k|         (void)m( result );
  163|  24.5k|         return result;
  164|  24.5k|      }
  165|  24.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  24.5k|      {
   73|  24.5k|#if defined( __cpp_exceptions )
   74|  24.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  24.5k|            try {
   76|  24.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  24.5k|            }
   78|  24.5k|            catch( ... ) {
   79|  24.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  24.5k|               throw;
   81|  24.5k|            }
   82|  24.5k|         }
   83|  24.5k|         else {
   84|  24.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  24.5k|      {
   44|  24.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  24.5k|   {
  104|  24.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  24.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  24.5k|      }
  107|  24.5k|      else {
  108|  24.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  24.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  24.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  24.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  24.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  24.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  24.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  24.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  24.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  24.5k|         }
  128|       |
  129|  24.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  24.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  24.5k|         }
  132|       |
  133|  24.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  24.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  24.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.60k, False: 20.9k]
  ------------------
  143|  3.60k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.60k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.60k|            }
  146|  3.60k|            else if constexpr( has_apply_bool ) {
  147|  3.60k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.60k|            }
  149|  3.60k|            else if constexpr( has_apply0_void ) {
  150|  3.60k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.60k|            }
  152|  3.60k|            else if constexpr( has_apply0_bool ) {
  153|  3.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.60k|            }
  155|  3.60k|         }
  156|  24.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.60k, False: 20.9k]
  ------------------
  157|  3.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.60k|         }
  159|  20.9k|         else {
  160|  20.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  20.9k|         }
  162|  24.5k|         (void)m( result );
  163|  24.5k|         return result;
  164|  24.5k|      }
  165|  24.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  24.5k|      {
   73|  24.5k|#if defined( __cpp_exceptions )
   74|  24.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  24.5k|            try {
   76|  24.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  24.5k|            }
   78|  24.5k|            catch( ... ) {
   79|  24.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  24.5k|               throw;
   81|  24.5k|            }
   82|  24.5k|         }
   83|  24.5k|         else {
   84|  24.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  24.5k|      {
   59|  24.5k|         return Rule::match( in );
   60|  24.5k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   115k|   {
  104|   115k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   115k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   115k|      }
  107|   115k|      else {
  108|   115k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   115k|         using iterator_t = typename ParseInput::iterator_t;
  111|   115k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   115k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   115k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   115k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   115k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   115k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   115k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   115k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   115k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   115k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   115k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   115k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   115k|         }
  128|       |
  129|   115k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   115k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   115k|         }
  132|       |
  133|   115k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   115k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   115k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   115k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   115k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   115k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   115k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   115k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 113k, False: 1.63k]
  ------------------
  143|   113k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   113k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   113k|            }
  146|   113k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   113k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   113k|            }
  149|   113k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   113k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   113k|            }
  152|   113k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   113k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   113k|            }
  155|   113k|         }
  156|   115k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 113k, False: 1.63k]
  ------------------
  157|   113k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   113k|         }
  159|  1.63k|         else {
  160|  1.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.63k|         }
  162|   115k|         (void)m( result );
  163|   115k|         return result;
  164|   115k|      }
  165|   115k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   115k|      {
   73|   115k|#if defined( __cpp_exceptions )
   74|   115k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   115k|            try {
   76|   115k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   115k|            }
   78|   115k|            catch( ... ) {
   79|   115k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   115k|               throw;
   81|   115k|            }
   82|   115k|         }
   83|   115k|         else {
   84|   115k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   115k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   115k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   115k|      {
   44|   115k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   115k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   115k|   {
  104|   115k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   115k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   115k|      }
  107|   115k|      else {
  108|   115k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   115k|         using iterator_t = typename ParseInput::iterator_t;
  111|   115k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   115k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   115k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   115k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   115k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   115k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   115k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   115k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   115k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   115k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   115k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   115k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   115k|         }
  128|       |
  129|   115k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   115k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   115k|         }
  132|       |
  133|   115k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   115k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   115k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   115k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   115k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   115k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   115k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   115k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 113k, False: 1.63k]
  ------------------
  143|   113k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   113k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   113k|            }
  146|   113k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   113k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   113k|            }
  149|   113k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   113k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   113k|            }
  152|   113k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   113k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   113k|            }
  155|   113k|         }
  156|   115k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 113k, False: 1.63k]
  ------------------
  157|   113k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   113k|         }
  159|  1.63k|         else {
  160|  1.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.63k|         }
  162|   115k|         (void)m( result );
  163|   115k|         return result;
  164|   115k|      }
  165|   115k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   115k|      {
   73|   115k|#if defined( __cpp_exceptions )
   74|   115k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   115k|            try {
   76|   115k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   115k|            }
   78|   115k|            catch( ... ) {
   79|   115k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   115k|               throw;
   81|   115k|            }
   82|   115k|         }
   83|   115k|         else {
   84|   115k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   115k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   115k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   115k|      {
   59|   115k|         return Rule::match( in );
   60|   115k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   130k|   {
  104|   130k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   130k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   130k|      }
  107|   130k|      else {
  108|   130k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   130k|         using iterator_t = typename ParseInput::iterator_t;
  111|   130k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   130k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   130k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   130k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   130k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   130k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   130k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   130k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   130k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   130k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   130k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   130k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   130k|         }
  128|       |
  129|   130k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   130k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   130k|         }
  132|       |
  133|   130k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   130k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   130k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   130k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   130k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   130k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   130k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   130k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11.7k, False: 118k]
  ------------------
  143|  11.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  11.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  11.7k|            }
  146|  11.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  11.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  11.7k|            }
  149|  11.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  11.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  11.7k|            }
  152|  11.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  11.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  11.7k|            }
  155|  11.7k|         }
  156|   130k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11.7k, False: 118k]
  ------------------
  157|  11.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  11.7k|         }
  159|   118k|         else {
  160|   118k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   118k|         }
  162|   130k|         (void)m( result );
  163|   130k|         return result;
  164|   130k|      }
  165|   130k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   130k|      {
   73|   130k|#if defined( __cpp_exceptions )
   74|   130k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   130k|            try {
   76|   130k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   130k|            }
   78|   130k|            catch( ... ) {
   79|   130k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   130k|               throw;
   81|   130k|            }
   82|   130k|         }
   83|   130k|         else {
   84|   130k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   130k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   130k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   130k|      {
   59|   130k|         return Rule::match( in );
   60|   130k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.16k, False: 418]
  ------------------
  143|  3.16k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.16k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.16k|            }
  146|  3.16k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.16k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.16k|            }
  149|  3.16k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.16k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.16k|            }
  152|  3.16k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.16k|            }
  155|  3.16k|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.16k, False: 418]
  ------------------
  157|  3.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.16k|         }
  159|    418|         else {
  160|    418|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    418|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|  3.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.58k|            try {
   76|  3.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.58k|            }
   78|  3.58k|            catch( ... ) {
   79|  3.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.58k|               throw;
   81|  3.58k|            }
   82|  3.58k|         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.58k|      {
   44|  3.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.58k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.40k, False: 1.18k]
  ------------------
  143|  2.40k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.40k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.40k|            }
  146|  2.40k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.40k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.40k|            }
  149|  2.40k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.40k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.40k|            }
  152|  2.40k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.40k|            }
  155|  2.40k|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 1.18k]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|  1.18k|         else {
  160|  1.18k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.18k|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|  3.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.58k|            try {
   76|  3.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.58k|            }
   78|  3.58k|            catch( ... ) {
   79|  3.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.58k|               throw;
   81|  3.58k|            }
   82|  3.58k|         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.58k|      {
   44|  3.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.58k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.58k, False: 0]
  ------------------
  143|  3.58k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.58k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.58k|            }
  146|  3.58k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.58k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.58k|            }
  149|  3.58k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.58k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.58k|            }
  152|  3.58k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.58k|            }
  155|  3.58k|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.58k, False: 0]
  ------------------
  157|  3.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.58k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|  3.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.58k|            try {
   76|  3.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.58k|            }
   78|  3.58k|            catch( ... ) {
   79|  3.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.58k|               throw;
   81|  3.58k|            }
   82|  3.58k|         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.58k|      {
   44|  3.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.58k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  143|  3.58k|            if constexpr( has_apply_void ) {
  144|  3.58k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.58k|            }
  146|  3.58k|            else if constexpr( has_apply_bool ) {
  147|  3.58k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.58k|            }
  149|  3.58k|            else if constexpr( has_apply0_void ) {
  150|  3.58k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.58k|            }
  152|  3.58k|            else if constexpr( has_apply0_bool ) {
  153|  3.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.58k|            }
  155|  3.58k|         }
  156|  3.58k|         if( result ) {
  157|  3.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.58k|         }
  159|  3.58k|         else {
  160|  3.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.58k|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.58k|      {
   44|  3.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.58k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, False: 1.72k]
  ------------------
  143|  1.86k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.86k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.86k|            }
  146|  1.86k|            else if constexpr( has_apply_bool ) {
  147|  1.86k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.86k|            }
  149|  1.86k|            else if constexpr( has_apply0_void ) {
  150|  1.86k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.86k|            }
  152|  1.86k|            else if constexpr( has_apply0_bool ) {
  153|  1.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.86k|            }
  155|  1.86k|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 1.72k]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|  1.72k|         else {
  160|  1.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.72k|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|  3.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.58k|            try {
   76|  3.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.58k|            }
   78|  3.58k|            catch( ... ) {
   79|  3.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.58k|               throw;
   81|  3.58k|            }
   82|  3.58k|         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.58k|      {
   44|  3.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.58k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 74, False: 3.51k]
  ------------------
  143|     74|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|     74|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|     74|            }
  146|     74|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|     74|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|     74|            }
  149|     74|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|     74|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|     74|            }
  152|     74|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|     74|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     74|            }
  155|     74|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 74, False: 3.51k]
  ------------------
  157|     74|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     74|         }
  159|  3.51k|         else {
  160|  3.51k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.51k|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|  3.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.58k|            try {
   76|  3.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.58k|            }
   78|  3.58k|            catch( ... ) {
   79|  3.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.58k|               throw;
   81|  3.58k|            }
   82|  3.58k|         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.58k|      {
   59|  3.58k|         return Rule::match( in );
   60|  3.58k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|  3.51k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.51k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.51k|      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.51k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.51k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.51k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.51k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.51k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.51k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.51k|         }
  128|       |
  129|  3.51k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.51k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.51k|         }
  132|       |
  133|  3.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 275, False: 3.23k]
  ------------------
  143|    275|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    275|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    275|            }
  146|    275|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    275|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    275|            }
  149|    275|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    275|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    275|            }
  152|    275|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    275|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    275|            }
  155|    275|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 275, False: 3.23k]
  ------------------
  157|    275|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    275|         }
  159|  3.23k|         else {
  160|  3.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.23k|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.51k|#if defined( __cpp_exceptions )
   74|  3.51k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.51k|            try {
   76|  3.51k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.51k|            }
   78|  3.51k|            catch( ... ) {
   79|  3.51k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.51k|               throw;
   81|  3.51k|            }
   82|  3.51k|         }
   83|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.51k|      {
   59|  3.51k|         return Rule::match( in );
   60|  3.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.23k|   {
  104|  3.23k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.23k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.23k|      }
  107|  3.23k|      else {
  108|  3.23k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.23k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.23k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.23k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.23k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.23k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.23k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.23k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.23k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.23k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.23k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.23k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.23k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.23k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.23k|         }
  128|       |
  129|  3.23k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.23k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.23k|         }
  132|       |
  133|  3.23k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.23k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.23k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.23k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.23k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.23k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.23k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.23k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 304, False: 2.93k]
  ------------------
  143|    304|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    304|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    304|            }
  146|    304|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    304|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    304|            }
  149|    304|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    304|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    304|            }
  152|    304|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    304|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    304|            }
  155|    304|         }
  156|  3.23k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 304, False: 2.93k]
  ------------------
  157|    304|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    304|         }
  159|  2.93k|         else {
  160|  2.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.93k|         }
  162|  3.23k|         (void)m( result );
  163|  3.23k|         return result;
  164|  3.23k|      }
  165|  3.23k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.23k|      {
   73|  3.23k|#if defined( __cpp_exceptions )
   74|  3.23k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.23k|            try {
   76|  3.23k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.23k|            }
   78|  3.23k|            catch( ... ) {
   79|  3.23k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.23k|               throw;
   81|  3.23k|            }
   82|  3.23k|         }
   83|  3.23k|         else {
   84|  3.23k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.23k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.23k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.23k|      {
   59|  3.23k|         return Rule::match( in );
   60|  3.23k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.93k|   {
  104|  2.93k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.93k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.93k|      }
  107|  2.93k|      else {
  108|  2.93k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.93k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.93k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.93k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.93k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.93k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.93k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.93k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.93k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.93k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.93k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.93k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.93k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.93k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.93k|         }
  128|       |
  129|  2.93k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.93k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.93k|         }
  132|       |
  133|  2.93k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.93k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.93k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.93k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.93k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.93k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.93k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.93k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 374, False: 2.56k]
  ------------------
  143|    374|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    374|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    374|            }
  146|    374|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    374|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    374|            }
  149|    374|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    374|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    374|            }
  152|    374|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    374|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    374|            }
  155|    374|         }
  156|  2.93k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 374, False: 2.56k]
  ------------------
  157|    374|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    374|         }
  159|  2.56k|         else {
  160|  2.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.56k|         }
  162|  2.93k|         (void)m( result );
  163|  2.93k|         return result;
  164|  2.93k|      }
  165|  2.93k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.93k|      {
   73|  2.93k|#if defined( __cpp_exceptions )
   74|  2.93k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.93k|            try {
   76|  2.93k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.93k|            }
   78|  2.93k|            catch( ... ) {
   79|  2.93k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.93k|               throw;
   81|  2.93k|            }
   82|  2.93k|         }
   83|  2.93k|         else {
   84|  2.93k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.93k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.93k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.93k|      {
   59|  2.93k|         return Rule::match( in );
   60|  2.93k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.56k|   {
  104|  2.56k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.56k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.56k|      }
  107|  2.56k|      else {
  108|  2.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.56k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.56k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.56k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.56k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.56k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.56k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.56k|         }
  128|       |
  129|  2.56k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.56k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.56k|         }
  132|       |
  133|  2.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 510, False: 2.05k]
  ------------------
  143|    510|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    510|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    510|            }
  146|    510|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    510|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    510|            }
  149|    510|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    510|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    510|            }
  152|    510|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    510|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    510|            }
  155|    510|         }
  156|  2.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 510, False: 2.05k]
  ------------------
  157|    510|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    510|         }
  159|  2.05k|         else {
  160|  2.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.05k|         }
  162|  2.56k|         (void)m( result );
  163|  2.56k|         return result;
  164|  2.56k|      }
  165|  2.56k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.56k|      {
   73|  2.56k|#if defined( __cpp_exceptions )
   74|  2.56k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.56k|            try {
   76|  2.56k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.56k|            }
   78|  2.56k|            catch( ... ) {
   79|  2.56k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.56k|               throw;
   81|  2.56k|            }
   82|  2.56k|         }
   83|  2.56k|         else {
   84|  2.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.56k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.56k|      {
   59|  2.56k|         return Rule::match( in );
   60|  2.56k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.05k|   {
  104|  2.05k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.05k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.05k|      }
  107|  2.05k|      else {
  108|  2.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.05k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.05k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.05k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.05k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.05k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.05k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.05k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.05k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.05k|         }
  128|       |
  129|  2.05k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.05k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.05k|         }
  132|       |
  133|  2.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 326, False: 1.72k]
  ------------------
  143|    326|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    326|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    326|            }
  146|    326|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    326|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    326|            }
  149|    326|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    326|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    326|            }
  152|    326|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    326|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    326|            }
  155|    326|         }
  156|  2.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 326, False: 1.72k]
  ------------------
  157|    326|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    326|         }
  159|  1.72k|         else {
  160|  1.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.72k|         }
  162|  2.05k|         (void)m( result );
  163|  2.05k|         return result;
  164|  2.05k|      }
  165|  2.05k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.05k|      {
   73|  2.05k|#if defined( __cpp_exceptions )
   74|  2.05k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.05k|            try {
   76|  2.05k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.05k|            }
   78|  2.05k|            catch( ... ) {
   79|  2.05k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.05k|               throw;
   81|  2.05k|            }
   82|  2.05k|         }
   83|  2.05k|         else {
   84|  2.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.05k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.05k|      {
   59|  2.05k|         return Rule::match( in );
   60|  2.05k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|  3.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.58k|      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.58k|         }
  128|       |
  129|  3.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.58k|         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.62k, False: 963]
  ------------------
  143|  2.62k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.62k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.62k|            }
  146|  2.62k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.62k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.62k|            }
  149|  2.62k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.62k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.62k|            }
  152|  2.62k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.62k|            }
  155|  2.62k|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.62k, False: 963]
  ------------------
  157|  2.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.62k|         }
  159|    963|         else {
  160|    963|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    963|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|  3.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.58k|            try {
   76|  3.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.58k|            }
   78|  3.58k|            catch( ... ) {
   79|  3.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.58k|               throw;
   81|  3.58k|            }
   82|  3.58k|         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.58k|      {
   59|  3.58k|         return Rule::match( in );
   60|  3.58k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.18k|   {
  104|  5.18k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.18k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.18k|      }
  107|  5.18k|      else {
  108|  5.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.18k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.18k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.18k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.18k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.18k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.18k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.18k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.18k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.18k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.18k|         }
  128|       |
  129|  5.18k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.18k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.18k|         }
  132|       |
  133|  5.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.18k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.18k, False: 0]
  ------------------
  143|  5.18k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.18k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.18k|            }
  146|  5.18k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.18k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.18k|            }
  149|  5.18k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.18k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.18k|            }
  152|  5.18k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.18k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.18k|            }
  155|  5.18k|         }
  156|  5.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.18k, False: 0]
  ------------------
  157|  5.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.18k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.18k|         (void)m( result );
  163|  5.18k|         return result;
  164|  5.18k|      }
  165|  5.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  5.18k|      {
   73|  5.18k|#if defined( __cpp_exceptions )
   74|  5.18k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.18k|            try {
   76|  5.18k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.18k|            }
   78|  5.18k|            catch( ... ) {
   79|  5.18k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.18k|               throw;
   81|  5.18k|            }
   82|  5.18k|         }
   83|  5.18k|         else {
   84|  5.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.18k|      {
   44|  5.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.18k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.62k|   {
  104|  2.62k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.62k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.62k|      }
  107|  2.62k|      else {
  108|  2.62k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.62k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.62k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.62k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.62k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.62k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.62k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.62k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.62k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.62k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.62k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.62k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.62k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.62k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.62k|         }
  128|       |
  129|  2.62k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.62k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.62k|         }
  132|       |
  133|  2.62k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.62k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.62k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.62k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.62k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.62k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.62k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.62k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.56k, False: 61]
  ------------------
  143|  2.56k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.56k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.56k|            }
  146|  2.56k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.56k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.56k|            }
  149|  2.56k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.56k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.56k|            }
  152|  2.56k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.56k|            }
  155|  2.56k|         }
  156|  2.62k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.56k, False: 61]
  ------------------
  157|  2.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.56k|         }
  159|     61|         else {
  160|     61|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     61|         }
  162|  2.62k|         (void)m( result );
  163|  2.62k|         return result;
  164|  2.62k|      }
  165|  2.62k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.62k|      {
   73|  2.62k|#if defined( __cpp_exceptions )
   74|  2.62k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.62k|            try {
   76|  2.62k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.62k|            }
   78|  2.62k|            catch( ... ) {
   79|  2.62k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.62k|               throw;
   81|  2.62k|            }
   82|  2.62k|         }
   83|  2.62k|         else {
   84|  2.62k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.62k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.62k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.62k|      {
   44|  2.62k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.62k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.56k|   {
  104|  2.56k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.56k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.56k|      }
  107|  2.56k|      else {
  108|  2.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  2.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  2.56k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  2.56k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  2.56k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  2.56k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  2.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.56k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  2.56k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.56k|         }
  128|       |
  129|  2.56k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  2.56k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.56k|         }
  132|       |
  133|  2.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  2.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.56k|         if( result ) {
  143|  2.56k|            if constexpr( has_apply_void ) {
  144|  2.56k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.56k|            }
  146|  2.56k|            else if constexpr( has_apply_bool ) {
  147|  2.56k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.56k|            }
  149|  2.56k|            else if constexpr( has_apply0_void ) {
  150|  2.56k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.56k|            }
  152|  2.56k|            else if constexpr( has_apply0_bool ) {
  153|  2.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.56k|            }
  155|  2.56k|         }
  156|  2.56k|         if( result ) {
  157|  2.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.56k|         }
  159|  2.56k|         else {
  160|  2.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.56k|         }
  162|  2.56k|         (void)m( result );
  163|  2.56k|         return result;
  164|  2.56k|      }
  165|  2.56k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.56k|      {
   44|  2.56k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.56k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   109k|   {
  104|   109k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   109k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   109k|      }
  107|   109k|      else {
  108|   109k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   109k|         using iterator_t = typename ParseInput::iterator_t;
  111|   109k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   109k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   109k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   109k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   109k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   109k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   109k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   109k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   109k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   109k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   109k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   109k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   109k|         }
  128|       |
  129|   109k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   109k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   109k|         }
  132|       |
  133|   109k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   109k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   109k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   109k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   109k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   109k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   109k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   109k|         if( result ) {
  143|   109k|            if constexpr( has_apply_void ) {
  144|   109k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   109k|            }
  146|   109k|            else if constexpr( has_apply_bool ) {
  147|   109k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   109k|            }
  149|   109k|            else if constexpr( has_apply0_void ) {
  150|   109k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   109k|            }
  152|   109k|            else if constexpr( has_apply0_bool ) {
  153|   109k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   109k|            }
  155|   109k|         }
  156|   109k|         if( result ) {
  157|   109k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   109k|         }
  159|   109k|         else {
  160|   109k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   109k|         }
  162|   109k|         (void)m( result );
  163|   109k|         return result;
  164|   109k|      }
  165|   109k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   109k|      {
   44|   109k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   109k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.56k|   {
  104|  2.56k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.56k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.56k|      }
  107|  2.56k|      else {
  108|  2.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.56k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.56k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.56k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.56k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.56k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.56k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.56k|         }
  128|       |
  129|  2.56k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.56k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.56k|         }
  132|       |
  133|  2.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.40k, False: 163]
  ------------------
  143|  2.40k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.40k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.40k|            }
  146|  2.40k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.40k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.40k|            }
  149|  2.40k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.40k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.40k|            }
  152|  2.40k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.40k|            }
  155|  2.40k|         }
  156|  2.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 163]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|    163|         else {
  160|    163|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    163|         }
  162|  2.56k|         (void)m( result );
  163|  2.56k|         return result;
  164|  2.56k|      }
  165|  2.56k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.56k|      {
   73|  2.56k|#if defined( __cpp_exceptions )
   74|  2.56k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.56k|            try {
   76|  2.56k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.56k|            }
   78|  2.56k|            catch( ... ) {
   79|  2.56k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.56k|               throw;
   81|  2.56k|            }
   82|  2.56k|         }
   83|  2.56k|         else {
   84|  2.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.56k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.56k|      {
   59|  2.56k|         return Rule::match( in );
   60|  2.56k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   111k|   {
  104|   111k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   111k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   111k|      }
  107|   111k|      else {
  108|   111k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   111k|         using iterator_t = typename ParseInput::iterator_t;
  111|   111k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   111k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   111k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   111k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   111k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   111k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   111k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   111k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   111k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   111k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   111k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   111k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   111k|         }
  128|       |
  129|   111k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   111k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   111k|         }
  132|       |
  133|   111k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   111k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   111k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   111k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   111k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   111k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   111k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   111k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 110k, False: 1.45k]
  ------------------
  143|   110k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   110k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   110k|            }
  146|   110k|            else if constexpr( has_apply_bool ) {
  147|   110k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   110k|            }
  149|   110k|            else if constexpr( has_apply0_void ) {
  150|   110k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   110k|            }
  152|   110k|            else if constexpr( has_apply0_bool ) {
  153|   110k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   110k|            }
  155|   110k|         }
  156|   111k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 110k, False: 1.45k]
  ------------------
  157|   110k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   110k|         }
  159|  1.45k|         else {
  160|  1.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.45k|         }
  162|   111k|         (void)m( result );
  163|   111k|         return result;
  164|   111k|      }
  165|   111k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   111k|      {
   73|   111k|#if defined( __cpp_exceptions )
   74|   111k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   111k|            try {
   76|   111k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   111k|            }
   78|   111k|            catch( ... ) {
   79|   111k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   111k|               throw;
   81|   111k|            }
   82|   111k|         }
   83|   111k|         else {
   84|   111k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   111k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   111k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   111k|      {
   44|   111k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   111k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   111k|   {
  104|   111k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   111k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   111k|      }
  107|   111k|      else {
  108|   111k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   111k|         using iterator_t = typename ParseInput::iterator_t;
  111|   111k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   111k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   111k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   111k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   111k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   111k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   111k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   111k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   111k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   111k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   111k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   111k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   111k|         }
  128|       |
  129|   111k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   111k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   111k|         }
  132|       |
  133|   111k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   111k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   111k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   111k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   111k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   111k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   111k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   111k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 110k, False: 1.33k]
  ------------------
  143|   110k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   110k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   110k|            }
  146|   110k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   110k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   110k|            }
  149|   110k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   110k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   110k|            }
  152|   110k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   110k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   110k|            }
  155|   110k|         }
  156|   111k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 110k, False: 1.33k]
  ------------------
  157|   110k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   110k|         }
  159|  1.33k|         else {
  160|  1.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.33k|         }
  162|   111k|         (void)m( result );
  163|   111k|         return result;
  164|   111k|      }
  165|   111k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   111k|      {
   73|   111k|#if defined( __cpp_exceptions )
   74|   111k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   111k|            try {
   76|   111k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   111k|            }
   78|   111k|            catch( ... ) {
   79|   111k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   111k|               throw;
   81|   111k|            }
   82|   111k|         }
   83|   111k|         else {
   84|   111k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   111k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   111k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   111k|      {
   44|   111k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   111k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   472k|   {
  104|   472k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   472k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   472k|      }
  107|   472k|      else {
  108|   472k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   472k|         using iterator_t = typename ParseInput::iterator_t;
  111|   472k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   472k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   472k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   472k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   472k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   472k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   472k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   472k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   472k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   472k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   472k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   472k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   472k|         }
  128|       |
  129|   472k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   472k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   472k|         }
  132|       |
  133|   472k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   472k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   472k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   472k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   472k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   472k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   472k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   472k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 278k, False: 193k]
  ------------------
  143|   278k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   278k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   278k|            }
  146|   278k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   278k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   278k|            }
  149|   278k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   278k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   278k|            }
  152|   278k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   278k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   278k|            }
  155|   278k|         }
  156|   472k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 278k, False: 193k]
  ------------------
  157|   278k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   278k|         }
  159|   193k|         else {
  160|   193k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   193k|         }
  162|   472k|         (void)m( result );
  163|   472k|         return result;
  164|   472k|      }
  165|   472k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   472k|      {
   73|   472k|#if defined( __cpp_exceptions )
   74|   472k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   472k|            try {
   76|   472k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   472k|            }
   78|   472k|            catch( ... ) {
   79|   472k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   472k|               throw;
   81|   472k|            }
   82|   472k|         }
   83|   472k|         else {
   84|   472k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   472k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   472k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   472k|      {
   59|   472k|         return Rule::match( in );
   60|   472k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   221k|   {
  104|   221k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   221k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   221k|      }
  107|   221k|      else {
  108|   221k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   221k|         using iterator_t = typename ParseInput::iterator_t;
  111|   221k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   221k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   221k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   221k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   221k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   221k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   221k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   221k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   221k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   221k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   221k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   221k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   221k|         }
  128|       |
  129|   221k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   221k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   221k|         }
  132|       |
  133|   221k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   221k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   221k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   221k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   221k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   221k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   221k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   221k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 221k, False: 70]
  ------------------
  143|   221k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   221k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   221k|            }
  146|   221k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   221k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   221k|            }
  149|   221k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   221k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   221k|            }
  152|   221k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   221k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   221k|            }
  155|   221k|         }
  156|   221k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 221k, False: 70]
  ------------------
  157|   221k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   221k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|   221k|         (void)m( result );
  163|   221k|         return result;
  164|   221k|      }
  165|   221k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   221k|      {
   73|   221k|#if defined( __cpp_exceptions )
   74|   221k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   221k|            try {
   76|   221k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   221k|            }
   78|   221k|            catch( ... ) {
   79|   221k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   221k|               throw;
   81|   221k|            }
   82|   221k|         }
   83|   221k|         else {
   84|   221k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   221k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   221k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   221k|      {
   59|   221k|         return Rule::match( in );
   60|   221k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   221k|   {
  104|   221k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   221k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   221k|      }
  107|   221k|      else {
  108|   221k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   221k|         using iterator_t = typename ParseInput::iterator_t;
  111|   221k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   221k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   221k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   221k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   221k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   221k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   221k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   221k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   221k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   221k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   221k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   221k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   221k|         }
  128|       |
  129|   221k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   221k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   221k|         }
  132|       |
  133|   221k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   221k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   221k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   221k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   221k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   221k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   221k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   221k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 221k, False: 51]
  ------------------
  143|   221k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   221k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   221k|            }
  146|   221k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   221k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   221k|            }
  149|   221k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   221k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   221k|            }
  152|   221k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   221k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   221k|            }
  155|   221k|         }
  156|   221k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 221k, False: 51]
  ------------------
  157|   221k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   221k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|   221k|         (void)m( result );
  163|   221k|         return result;
  164|   221k|      }
  165|   221k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   221k|      {
   73|   221k|#if defined( __cpp_exceptions )
   74|   221k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   221k|            try {
   76|   221k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   221k|            }
   78|   221k|            catch( ... ) {
   79|   221k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   221k|               throw;
   81|   221k|            }
   82|   221k|         }
   83|   221k|         else {
   84|   221k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   221k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   221k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   221k|      {
   44|   221k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   221k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   221k|   {
  104|   221k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   221k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   221k|      }
  107|   221k|      else {
  108|   221k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   221k|         using iterator_t = typename ParseInput::iterator_t;
  111|   221k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   221k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   221k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   221k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   221k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   221k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   221k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   221k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   221k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   221k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   221k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   221k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   221k|         }
  128|       |
  129|   221k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   221k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   221k|         }
  132|       |
  133|   221k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   221k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   221k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   221k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   221k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   221k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   221k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   221k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.4k, False: 192k]
  ------------------
  143|  28.4k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  28.4k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.4k|            }
  146|  28.4k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  28.4k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.4k|            }
  149|  28.4k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  28.4k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.4k|            }
  152|  28.4k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  28.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.4k|            }
  155|  28.4k|         }
  156|   221k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.4k, False: 192k]
  ------------------
  157|  28.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.4k|         }
  159|   192k|         else {
  160|   192k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   192k|         }
  162|   221k|         (void)m( result );
  163|   221k|         return result;
  164|   221k|      }
  165|   221k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   221k|      {
   73|   221k|#if defined( __cpp_exceptions )
   74|   221k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   221k|            try {
   76|   221k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   221k|            }
   78|   221k|            catch( ... ) {
   79|   221k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   221k|               throw;
   81|   221k|            }
   82|   221k|         }
   83|   221k|         else {
   84|   221k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   221k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   221k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   221k|      {
   44|   221k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   221k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   192k|   {
  104|   192k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   192k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   192k|      }
  107|   192k|      else {
  108|   192k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   192k|         using iterator_t = typename ParseInput::iterator_t;
  111|   192k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   192k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   192k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   192k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   192k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   192k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   192k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   192k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   192k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   192k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   192k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   192k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   192k|         }
  128|       |
  129|   192k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   192k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   192k|         }
  132|       |
  133|   192k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   192k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   192k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   192k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   192k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   192k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   192k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   192k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 192k, False: 51]
  ------------------
  143|   192k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   192k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   192k|            }
  146|   192k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   192k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   192k|            }
  149|   192k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   192k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   192k|            }
  152|   192k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   192k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   192k|            }
  155|   192k|         }
  156|   192k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 192k, False: 51]
  ------------------
  157|   192k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   192k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|   192k|         (void)m( result );
  163|   192k|         return result;
  164|   192k|      }
  165|   192k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   192k|      {
   73|   192k|#if defined( __cpp_exceptions )
   74|   192k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   192k|            try {
   76|   192k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   192k|            }
   78|   192k|            catch( ... ) {
   79|   192k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   192k|               throw;
   81|   192k|            }
   82|   192k|         }
   83|   192k|         else {
   84|   192k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   192k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   192k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   192k|      {
   59|   192k|         return Rule::match( in );
   60|   192k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  21.3k|   {
  104|  21.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  21.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  21.3k|      }
  107|  21.3k|      else {
  108|  21.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  21.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  21.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  21.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  21.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  21.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  21.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  21.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  21.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  21.3k|         }
  128|       |
  129|  21.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  21.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  21.3k|         }
  132|       |
  133|  21.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  21.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  21.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 18.4k]
  ------------------
  143|  2.90k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.90k|            }
  146|  2.90k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.90k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.90k|            }
  149|  2.90k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.90k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.90k|            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  21.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 18.4k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  18.4k|         else {
  160|  18.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  18.4k|         }
  162|  21.3k|         (void)m( result );
  163|  21.3k|         return result;
  164|  21.3k|      }
  165|  21.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  21.3k|      {
   73|  21.3k|#if defined( __cpp_exceptions )
   74|  21.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  21.3k|            try {
   76|  21.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  21.3k|            }
   78|  21.3k|            catch( ... ) {
   79|  21.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  21.3k|               throw;
   81|  21.3k|            }
   82|  21.3k|         }
   83|  21.3k|         else {
   84|  21.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  21.3k|      {
   44|  21.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  21.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  21.3k|   {
  104|  21.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  21.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  21.3k|      }
  107|  21.3k|      else {
  108|  21.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  21.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  21.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  21.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  21.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  21.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  21.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  21.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  21.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  21.3k|         }
  128|       |
  129|  21.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  21.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  21.3k|         }
  132|       |
  133|  21.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  21.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  21.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 18.4k]
  ------------------
  143|  2.90k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.90k|            }
  146|  2.90k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.90k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.90k|            }
  149|  2.90k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.90k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.90k|            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  21.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 18.4k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  18.4k|         else {
  160|  18.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  18.4k|         }
  162|  21.3k|         (void)m( result );
  163|  21.3k|         return result;
  164|  21.3k|      }
  165|  21.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  21.3k|      {
   73|  21.3k|#if defined( __cpp_exceptions )
   74|  21.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  21.3k|            try {
   76|  21.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  21.3k|            }
   78|  21.3k|            catch( ... ) {
   79|  21.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  21.3k|               throw;
   81|  21.3k|            }
   82|  21.3k|         }
   83|  21.3k|         else {
   84|  21.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  21.3k|      {
   44|  21.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  21.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  21.3k|   {
  104|  21.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  21.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  21.3k|      }
  107|  21.3k|      else {
  108|  21.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  21.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  21.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  21.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  21.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  21.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  21.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  21.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  21.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  21.3k|         }
  128|       |
  129|  21.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  21.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  21.3k|         }
  132|       |
  133|  21.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  21.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  21.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.52k, False: 17.8k]
  ------------------
  143|  3.52k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.52k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.52k|            }
  146|  3.52k|            else if constexpr( has_apply_bool ) {
  147|  3.52k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.52k|            }
  149|  3.52k|            else if constexpr( has_apply0_void ) {
  150|  3.52k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.52k|            }
  152|  3.52k|            else if constexpr( has_apply0_bool ) {
  153|  3.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.52k|            }
  155|  3.52k|         }
  156|  21.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.51k, False: 17.8k]
  ------------------
  157|  3.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.51k|         }
  159|  17.8k|         else {
  160|  17.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.8k|         }
  162|  21.3k|         (void)m( result );
  163|  21.3k|         return result;
  164|  21.3k|      }
  165|  21.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  21.3k|      {
   73|  21.3k|#if defined( __cpp_exceptions )
   74|  21.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  21.3k|            try {
   76|  21.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  21.3k|            }
   78|  21.3k|            catch( ... ) {
   79|  21.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  21.3k|               throw;
   81|  21.3k|            }
   82|  21.3k|         }
   83|  21.3k|         else {
   84|  21.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  21.3k|      {
   59|  21.3k|         return Rule::match( in );
   60|  21.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.44k|   {
  104|  9.44k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.44k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.44k|      }
  107|  9.44k|      else {
  108|  9.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.44k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.44k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.44k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.44k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.44k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.44k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.44k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.44k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.44k|         }
  128|       |
  129|  9.44k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.44k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.44k|         }
  132|       |
  133|  9.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.79k, False: 1.65k]
  ------------------
  143|  7.79k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.79k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.79k|            }
  146|  7.79k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.79k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.79k|            }
  149|  7.79k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.79k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.79k|            }
  152|  7.79k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.79k|            }
  155|  7.79k|         }
  156|  9.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.79k, False: 1.65k]
  ------------------
  157|  7.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.79k|         }
  159|  1.65k|         else {
  160|  1.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.65k|         }
  162|  9.44k|         (void)m( result );
  163|  9.44k|         return result;
  164|  9.44k|      }
  165|  9.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  9.44k|      {
   73|  9.44k|#if defined( __cpp_exceptions )
   74|  9.44k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.44k|            try {
   76|  9.44k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.44k|            }
   78|  9.44k|            catch( ... ) {
   79|  9.44k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.44k|               throw;
   81|  9.44k|            }
   82|  9.44k|         }
   83|  9.44k|         else {
   84|  9.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.44k|      {
   44|  9.44k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.44k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.44k|   {
  104|  9.44k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  9.44k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  9.44k|      }
  107|  9.44k|      else {
  108|  9.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.44k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  9.44k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  9.44k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  9.44k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  9.44k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  9.44k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  9.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  9.44k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  9.44k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  9.44k|         }
  128|       |
  129|  9.44k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  9.44k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  9.44k|         }
  132|       |
  133|  9.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  9.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.79k, False: 1.65k]
  ------------------
  143|  7.79k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.79k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.79k|            }
  146|  7.79k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.79k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.79k|            }
  149|  7.79k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.79k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.79k|            }
  152|  7.79k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.79k|            }
  155|  7.79k|         }
  156|  9.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.79k, False: 1.65k]
  ------------------
  157|  7.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.79k|         }
  159|  1.65k|         else {
  160|  1.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.65k|         }
  162|  9.44k|         (void)m( result );
  163|  9.44k|         return result;
  164|  9.44k|      }
  165|  9.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.44k|      {
   73|  9.44k|#if defined( __cpp_exceptions )
   74|  9.44k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  9.44k|            try {
   76|  9.44k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  9.44k|            }
   78|  9.44k|            catch( ... ) {
   79|  9.44k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  9.44k|               throw;
   81|  9.44k|            }
   82|  9.44k|         }
   83|  9.44k|         else {
   84|  9.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.44k|      {
   59|  9.44k|         return Rule::match( in );
   60|  9.44k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  19.0k|   {
  104|  19.0k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  19.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  19.0k|      }
  107|  19.0k|      else {
  108|  19.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  19.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  19.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  19.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  19.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  19.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  19.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  19.0k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  19.0k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  19.0k|         }
  128|       |
  129|  19.0k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  19.0k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  19.0k|         }
  132|       |
  133|  19.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  19.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.80k, False: 13.2k]
  ------------------
  143|  5.80k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.80k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.80k|            }
  146|  5.80k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.80k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.80k|            }
  149|  5.80k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.80k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.80k|            }
  152|  5.80k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.80k|            }
  155|  5.80k|         }
  156|  19.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.80k, False: 13.2k]
  ------------------
  157|  5.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.80k|         }
  159|  13.2k|         else {
  160|  13.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.2k|         }
  162|  19.0k|         (void)m( result );
  163|  19.0k|         return result;
  164|  19.0k|      }
  165|  19.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  19.0k|      {
   73|  19.0k|#if defined( __cpp_exceptions )
   74|  19.0k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  19.0k|            try {
   76|  19.0k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  19.0k|            }
   78|  19.0k|            catch( ... ) {
   79|  19.0k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  19.0k|               throw;
   81|  19.0k|            }
   82|  19.0k|         }
   83|  19.0k|         else {
   84|  19.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  19.0k|      {
   59|  19.0k|         return Rule::match( in );
   60|  19.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 604]
  ------------------
  143|  2.90k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.90k|            }
  146|  2.90k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.90k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.90k|            }
  149|  2.90k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.90k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.90k|            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 604]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|    604|         else {
  160|    604|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    604|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.50k|      {
   73|  3.50k|#if defined( __cpp_exceptions )
   74|  3.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.50k|            try {
   76|  3.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.50k|            }
   78|  3.50k|            catch( ... ) {
   79|  3.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.50k|               throw;
   81|  3.50k|            }
   82|  3.50k|         }
   83|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.50k|      {
   44|  3.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.50k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.58k, False: 921]
  ------------------
  143|  2.58k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.58k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.58k|            }
  146|  2.58k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.58k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.58k|            }
  149|  2.58k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.58k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.58k|            }
  152|  2.58k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 921]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|    921|         else {
  160|    921|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    921|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.50k|      {
   73|  3.50k|#if defined( __cpp_exceptions )
   74|  3.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.50k|            try {
   76|  3.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.50k|            }
   78|  3.50k|            catch( ... ) {
   79|  3.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.50k|               throw;
   81|  3.50k|            }
   82|  3.50k|         }
   83|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.50k|      {
   44|  3.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.50k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.50k, False: 0]
  ------------------
  143|  3.50k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.50k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.50k|            }
  146|  3.50k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.50k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.50k|            }
  149|  3.50k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.50k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.50k|            }
  152|  3.50k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.50k|            }
  155|  3.50k|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.50k, False: 0]
  ------------------
  157|  3.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.50k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.50k|      {
   73|  3.50k|#if defined( __cpp_exceptions )
   74|  3.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.50k|            try {
   76|  3.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.50k|            }
   78|  3.50k|            catch( ... ) {
   79|  3.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.50k|               throw;
   81|  3.50k|            }
   82|  3.50k|         }
   83|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.50k|      {
   44|  3.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.50k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  143|  3.50k|            if constexpr( has_apply_void ) {
  144|  3.50k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.50k|            }
  146|  3.50k|            else if constexpr( has_apply_bool ) {
  147|  3.50k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.50k|            }
  149|  3.50k|            else if constexpr( has_apply0_void ) {
  150|  3.50k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.50k|            }
  152|  3.50k|            else if constexpr( has_apply0_bool ) {
  153|  3.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.50k|            }
  155|  3.50k|         }
  156|  3.50k|         if( result ) {
  157|  3.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.50k|         }
  159|  3.50k|         else {
  160|  3.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.50k|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.50k|      {
   44|  3.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.50k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44k, False: 2.06k]
  ------------------
  143|  1.44k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.44k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.44k|            }
  146|  1.44k|            else if constexpr( has_apply_bool ) {
  147|  1.44k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.44k|            }
  149|  1.44k|            else if constexpr( has_apply0_void ) {
  150|  1.44k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.44k|            }
  152|  1.44k|            else if constexpr( has_apply0_bool ) {
  153|  1.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.44k|            }
  155|  1.44k|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44k, False: 2.06k]
  ------------------
  157|  1.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44k|         }
  159|  2.06k|         else {
  160|  2.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.06k|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.50k|      {
   73|  3.50k|#if defined( __cpp_exceptions )
   74|  3.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.50k|            try {
   76|  3.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.50k|            }
   78|  3.50k|            catch( ... ) {
   79|  3.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.50k|               throw;
   81|  3.50k|            }
   82|  3.50k|         }
   83|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.50k|      {
   44|  3.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.50k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 358, False: 3.14k]
  ------------------
  143|    358|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    358|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    358|            }
  146|    358|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    358|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    358|            }
  149|    358|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    358|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    358|            }
  152|    358|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    358|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    358|            }
  155|    358|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 358, False: 3.14k]
  ------------------
  157|    358|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    358|         }
  159|  3.14k|         else {
  160|  3.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.14k|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.50k|      {
   73|  3.50k|#if defined( __cpp_exceptions )
   74|  3.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.50k|            try {
   76|  3.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.50k|            }
   78|  3.50k|            catch( ... ) {
   79|  3.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.50k|               throw;
   81|  3.50k|            }
   82|  3.50k|         }
   83|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.50k|      {
   59|  3.50k|         return Rule::match( in );
   60|  3.50k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.14k|   {
  104|  3.14k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.14k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.14k|      }
  107|  3.14k|      else {
  108|  3.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.14k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.14k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.14k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.14k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.14k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.14k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.14k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.14k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.14k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.14k|         }
  128|       |
  129|  3.14k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.14k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.14k|         }
  132|       |
  133|  3.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.14k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 231, False: 2.91k]
  ------------------
  143|    231|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    231|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    231|            }
  146|    231|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    231|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    231|            }
  149|    231|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    231|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    231|            }
  152|    231|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    231|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    231|            }
  155|    231|         }
  156|  3.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 231, False: 2.91k]
  ------------------
  157|    231|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    231|         }
  159|  2.91k|         else {
  160|  2.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.91k|         }
  162|  3.14k|         (void)m( result );
  163|  3.14k|         return result;
  164|  3.14k|      }
  165|  3.14k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.14k|      {
   73|  3.14k|#if defined( __cpp_exceptions )
   74|  3.14k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.14k|            try {
   76|  3.14k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.14k|            }
   78|  3.14k|            catch( ... ) {
   79|  3.14k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.14k|               throw;
   81|  3.14k|            }
   82|  3.14k|         }
   83|  3.14k|         else {
   84|  3.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.14k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.14k|      {
   59|  3.14k|         return Rule::match( in );
   60|  3.14k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.91k|   {
  104|  2.91k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.91k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.91k|      }
  107|  2.91k|      else {
  108|  2.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.91k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.91k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.91k|         }
  128|       |
  129|  2.91k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.91k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.91k|         }
  132|       |
  133|  2.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.91k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 330, False: 2.58k]
  ------------------
  143|    330|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    330|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    330|            }
  146|    330|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    330|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    330|            }
  149|    330|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    330|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    330|            }
  152|    330|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    330|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    330|            }
  155|    330|         }
  156|  2.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 330, False: 2.58k]
  ------------------
  157|    330|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    330|         }
  159|  2.58k|         else {
  160|  2.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.58k|         }
  162|  2.91k|         (void)m( result );
  163|  2.91k|         return result;
  164|  2.91k|      }
  165|  2.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.91k|      {
   73|  2.91k|#if defined( __cpp_exceptions )
   74|  2.91k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.91k|            try {
   76|  2.91k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.91k|            }
   78|  2.91k|            catch( ... ) {
   79|  2.91k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.91k|               throw;
   81|  2.91k|            }
   82|  2.91k|         }
   83|  2.91k|         else {
   84|  2.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.91k|      {
   59|  2.91k|         return Rule::match( in );
   60|  2.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.58k|   {
  104|  2.58k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.58k|      }
  107|  2.58k|      else {
  108|  2.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.58k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.58k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.58k|         }
  128|       |
  129|  2.58k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.58k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.58k|         }
  132|       |
  133|  2.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.39k]
  ------------------
  143|    194|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    194|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    194|            }
  146|    194|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    194|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    194|            }
  149|    194|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    194|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    194|            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  2.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.39k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.39k|         else {
  160|  2.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.39k|         }
  162|  2.58k|         (void)m( result );
  163|  2.58k|         return result;
  164|  2.58k|      }
  165|  2.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.58k|      {
   73|  2.58k|#if defined( __cpp_exceptions )
   74|  2.58k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.58k|            try {
   76|  2.58k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.58k|            }
   78|  2.58k|            catch( ... ) {
   79|  2.58k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.58k|               throw;
   81|  2.58k|            }
   82|  2.58k|         }
   83|  2.58k|         else {
   84|  2.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.58k|      {
   59|  2.58k|         return Rule::match( in );
   60|  2.58k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.39k|   {
  104|  2.39k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.39k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.39k|      }
  107|  2.39k|      else {
  108|  2.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.39k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.39k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.39k|         }
  128|       |
  129|  2.39k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.39k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.39k|         }
  132|       |
  133|  2.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.39k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 131, False: 2.26k]
  ------------------
  143|    131|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    131|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    131|            }
  146|    131|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    131|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    131|            }
  149|    131|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    131|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    131|            }
  152|    131|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    131|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    131|            }
  155|    131|         }
  156|  2.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 131, False: 2.26k]
  ------------------
  157|    131|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    131|         }
  159|  2.26k|         else {
  160|  2.26k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.26k|         }
  162|  2.39k|         (void)m( result );
  163|  2.39k|         return result;
  164|  2.39k|      }
  165|  2.39k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.39k|      {
   73|  2.39k|#if defined( __cpp_exceptions )
   74|  2.39k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.39k|            try {
   76|  2.39k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.39k|            }
   78|  2.39k|            catch( ... ) {
   79|  2.39k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.39k|               throw;
   81|  2.39k|            }
   82|  2.39k|         }
   83|  2.39k|         else {
   84|  2.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.39k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.39k|      {
   59|  2.39k|         return Rule::match( in );
   60|  2.39k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.26k|   {
  104|  2.26k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.26k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.26k|      }
  107|  2.26k|      else {
  108|  2.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.26k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.26k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.26k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.26k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.26k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.26k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.26k|         }
  128|       |
  129|  2.26k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.26k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.26k|         }
  132|       |
  133|  2.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 200, False: 2.06k]
  ------------------
  143|    200|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    200|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    200|            }
  146|    200|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    200|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    200|            }
  149|    200|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    200|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    200|            }
  152|    200|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    200|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    200|            }
  155|    200|         }
  156|  2.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 200, False: 2.06k]
  ------------------
  157|    200|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    200|         }
  159|  2.06k|         else {
  160|  2.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.06k|         }
  162|  2.26k|         (void)m( result );
  163|  2.26k|         return result;
  164|  2.26k|      }
  165|  2.26k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.26k|      {
   73|  2.26k|#if defined( __cpp_exceptions )
   74|  2.26k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.26k|            try {
   76|  2.26k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.26k|            }
   78|  2.26k|            catch( ... ) {
   79|  2.26k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.26k|               throw;
   81|  2.26k|            }
   82|  2.26k|         }
   83|  2.26k|         else {
   84|  2.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.26k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.26k|      {
   59|  2.26k|         return Rule::match( in );
   60|  2.26k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.50k|   {
  104|  3.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.50k|      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.50k|         }
  128|       |
  129|  3.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.50k|         }
  132|       |
  133|  3.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.74k, False: 759]
  ------------------
  143|  2.74k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.74k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.74k|            }
  146|  2.74k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.74k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.74k|            }
  149|  2.74k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.74k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.74k|            }
  152|  2.74k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.74k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.74k|            }
  155|  2.74k|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.74k, False: 759]
  ------------------
  157|  2.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.74k|         }
  159|    759|         else {
  160|    759|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    759|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.50k|      {
   73|  3.50k|#if defined( __cpp_exceptions )
   74|  3.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.50k|            try {
   76|  3.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.50k|            }
   78|  3.50k|            catch( ... ) {
   79|  3.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.50k|               throw;
   81|  3.50k|            }
   82|  3.50k|         }
   83|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.50k|      {
   59|  3.50k|         return Rule::match( in );
   60|  3.50k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.43k|   {
  104|  5.43k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.43k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.43k|      }
  107|  5.43k|      else {
  108|  5.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.43k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.43k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.43k|         }
  128|       |
  129|  5.43k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.43k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.43k|         }
  132|       |
  133|  5.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.43k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.43k, False: 0]
  ------------------
  143|  5.43k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.43k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.43k|            }
  146|  5.43k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.43k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.43k|            }
  149|  5.43k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.43k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.43k|            }
  152|  5.43k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.43k|            }
  155|  5.43k|         }
  156|  5.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.43k, False: 0]
  ------------------
  157|  5.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.43k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.43k|         (void)m( result );
  163|  5.43k|         return result;
  164|  5.43k|      }
  165|  5.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  5.43k|      {
   73|  5.43k|#if defined( __cpp_exceptions )
   74|  5.43k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.43k|            try {
   76|  5.43k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.43k|            }
   78|  5.43k|            catch( ... ) {
   79|  5.43k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.43k|               throw;
   81|  5.43k|            }
   82|  5.43k|         }
   83|  5.43k|         else {
   84|  5.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.43k|      {
   44|  5.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.43k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|  2.74k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.74k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.74k|      }
  107|  2.74k|      else {
  108|  2.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.74k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.74k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.74k|         }
  128|       |
  129|  2.74k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.74k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.74k|         }
  132|       |
  133|  2.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.74k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.69k, False: 54]
  ------------------
  143|  2.69k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.69k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.69k|            }
  146|  2.69k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.69k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.69k|            }
  149|  2.69k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.69k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.69k|            }
  152|  2.69k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.69k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.69k|            }
  155|  2.69k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.69k, False: 54]
  ------------------
  157|  2.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.69k|         }
  159|     54|         else {
  160|     54|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     54|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.74k|      {
   73|  2.74k|#if defined( __cpp_exceptions )
   74|  2.74k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.74k|            try {
   76|  2.74k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.74k|            }
   78|  2.74k|            catch( ... ) {
   79|  2.74k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.74k|               throw;
   81|  2.74k|            }
   82|  2.74k|         }
   83|  2.74k|         else {
   84|  2.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.74k|      {
   44|  2.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.74k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.70k|   {
  104|  2.70k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.70k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.70k|      }
  107|  2.70k|      else {
  108|  2.70k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.70k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.70k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  2.70k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  2.70k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  2.70k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  2.70k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  2.70k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  2.70k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.70k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.70k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.70k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.70k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  2.70k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.70k|         }
  128|       |
  129|  2.70k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  2.70k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.70k|         }
  132|       |
  133|  2.70k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.70k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.70k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.70k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  2.70k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.70k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.70k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.70k|         if( result ) {
  143|  2.70k|            if constexpr( has_apply_void ) {
  144|  2.70k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.70k|            }
  146|  2.70k|            else if constexpr( has_apply_bool ) {
  147|  2.70k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.70k|            }
  149|  2.70k|            else if constexpr( has_apply0_void ) {
  150|  2.70k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.70k|            }
  152|  2.70k|            else if constexpr( has_apply0_bool ) {
  153|  2.70k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.70k|            }
  155|  2.70k|         }
  156|  2.70k|         if( result ) {
  157|  2.70k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.70k|         }
  159|  2.70k|         else {
  160|  2.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.70k|         }
  162|  2.70k|         (void)m( result );
  163|  2.70k|         return result;
  164|  2.70k|      }
  165|  2.70k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.70k|      {
   44|  2.70k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.70k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.48k|   {
  104|  4.48k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.48k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.48k|      }
  107|  4.48k|      else {
  108|  4.48k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.48k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.48k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.48k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.48k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.48k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.48k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.48k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.48k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.48k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.48k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.48k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.48k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.48k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.48k|         }
  128|       |
  129|  4.48k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.48k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.48k|         }
  132|       |
  133|  4.48k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.48k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.48k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.48k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.48k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.48k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.48k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.48k|         if( result ) {
  143|  4.48k|            if constexpr( has_apply_void ) {
  144|  4.48k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.48k|            }
  146|  4.48k|            else if constexpr( has_apply_bool ) {
  147|  4.48k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.48k|            }
  149|  4.48k|            else if constexpr( has_apply0_void ) {
  150|  4.48k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.48k|            }
  152|  4.48k|            else if constexpr( has_apply0_bool ) {
  153|  4.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.48k|            }
  155|  4.48k|         }
  156|  4.48k|         if( result ) {
  157|  4.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.48k|         }
  159|  4.48k|         else {
  160|  4.48k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.48k|         }
  162|  4.48k|         (void)m( result );
  163|  4.48k|         return result;
  164|  4.48k|      }
  165|  4.48k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.48k|      {
   44|  4.48k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.48k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.69k|   {
  104|  2.69k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.69k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.69k|      }
  107|  2.69k|      else {
  108|  2.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.69k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.69k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.69k|         }
  128|       |
  129|  2.69k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.69k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.69k|         }
  132|       |
  133|  2.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.69k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.58k, False: 108]
  ------------------
  143|  2.58k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.58k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.58k|            }
  146|  2.58k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.58k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.58k|            }
  149|  2.58k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.58k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.58k|            }
  152|  2.58k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  2.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 108]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|    108|         else {
  160|    108|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    108|         }
  162|  2.69k|         (void)m( result );
  163|  2.69k|         return result;
  164|  2.69k|      }
  165|  2.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.69k|      {
   73|  2.69k|#if defined( __cpp_exceptions )
   74|  2.69k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.69k|            try {
   76|  2.69k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.69k|            }
   78|  2.69k|            catch( ... ) {
   79|  2.69k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.69k|               throw;
   81|  2.69k|            }
   82|  2.69k|         }
   83|  2.69k|         else {
   84|  2.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.69k|      {
   59|  2.69k|         return Rule::match( in );
   60|  2.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.52k|   {
  104|  6.52k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.52k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.52k|      }
  107|  6.52k|      else {
  108|  6.52k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.52k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.52k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.52k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.52k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.52k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.52k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.52k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.52k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.52k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.52k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.52k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.52k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.52k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.52k|         }
  128|       |
  129|  6.52k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.52k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.52k|         }
  132|       |
  133|  6.52k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.52k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.52k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.52k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.52k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.52k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.52k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.52k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.85k, False: 1.67k]
  ------------------
  143|  4.85k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.85k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.85k|            }
  146|  4.85k|            else if constexpr( has_apply_bool ) {
  147|  4.85k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.85k|            }
  149|  4.85k|            else if constexpr( has_apply0_void ) {
  150|  4.85k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.85k|            }
  152|  4.85k|            else if constexpr( has_apply0_bool ) {
  153|  4.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.85k|            }
  155|  4.85k|         }
  156|  6.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.80k, False: 1.72k]
  ------------------
  157|  4.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.80k|         }
  159|  1.72k|         else {
  160|  1.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.72k|         }
  162|  6.52k|         (void)m( result );
  163|  6.52k|         return result;
  164|  6.52k|      }
  165|  6.52k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.52k|      {
   73|  6.52k|#if defined( __cpp_exceptions )
   74|  6.52k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.52k|            try {
   76|  6.52k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.52k|            }
   78|  6.52k|            catch( ... ) {
   79|  6.52k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.52k|               throw;
   81|  6.52k|            }
   82|  6.52k|         }
   83|  6.52k|         else {
   84|  6.52k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.52k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.52k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.52k|      {
   44|  6.52k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.52k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.52k|   {
  104|  6.52k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.52k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.52k|      }
  107|  6.52k|      else {
  108|  6.52k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.52k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.52k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.52k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.52k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.52k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.52k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.52k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.52k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.52k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.52k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.52k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.52k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.52k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.52k|         }
  128|       |
  129|  6.52k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.52k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.52k|         }
  132|       |
  133|  6.52k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.52k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.52k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.52k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.52k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.52k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.52k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.52k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.15k, False: 1.37k]
  ------------------
  143|  5.15k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.15k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.15k|            }
  146|  5.15k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.15k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.15k|            }
  149|  5.15k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.15k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.15k|            }
  152|  5.15k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.15k|            }
  155|  5.15k|         }
  156|  6.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.15k, False: 1.37k]
  ------------------
  157|  5.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.15k|         }
  159|  1.37k|         else {
  160|  1.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.37k|         }
  162|  6.52k|         (void)m( result );
  163|  6.52k|         return result;
  164|  6.52k|      }
  165|  6.52k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.52k|      {
   73|  6.52k|#if defined( __cpp_exceptions )
   74|  6.52k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.52k|            try {
   76|  6.52k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.52k|            }
   78|  6.52k|            catch( ... ) {
   79|  6.52k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.52k|               throw;
   81|  6.52k|            }
   82|  6.52k|         }
   83|  6.52k|         else {
   84|  6.52k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.52k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.52k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.52k|      {
   59|  6.52k|         return Rule::match( in );
   60|  6.52k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.15k|   {
  104|  5.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.15k|      }
  107|  5.15k|      else {
  108|  5.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  5.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  5.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  5.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  5.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  5.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  5.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  5.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.15k|         }
  128|       |
  129|  5.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  5.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.15k|         }
  132|       |
  133|  5.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  5.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.15k|         if( result ) {
  143|  5.15k|            if constexpr( has_apply_void ) {
  144|  5.15k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.15k|            }
  146|  5.15k|            else if constexpr( has_apply_bool ) {
  147|  5.15k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.15k|            }
  149|  5.15k|            else if constexpr( has_apply0_void ) {
  150|  5.15k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.15k|            }
  152|  5.15k|            else if constexpr( has_apply0_bool ) {
  153|  5.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.15k|            }
  155|  5.15k|         }
  156|  5.15k|         if( result ) {
  157|  5.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.15k|         }
  159|  5.15k|         else {
  160|  5.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.15k|         }
  162|  5.15k|         (void)m( result );
  163|  5.15k|         return result;
  164|  5.15k|      }
  165|  5.15k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.15k|      {
   44|  5.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.15k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.15k|   {
  104|  5.15k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.15k|      }
  107|  5.15k|      else {
  108|  5.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.15k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.15k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.15k|         }
  128|       |
  129|  5.15k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.15k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.15k|         }
  132|       |
  133|  5.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.85k, False: 299]
  ------------------
  143|  4.85k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.85k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.85k|            }
  146|  4.85k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.85k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.85k|            }
  149|  4.85k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.85k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.85k|            }
  152|  4.85k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.85k|            }
  155|  4.85k|         }
  156|  5.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.85k, False: 299]
  ------------------
  157|  4.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.85k|         }
  159|    299|         else {
  160|    299|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    299|         }
  162|  5.15k|         (void)m( result );
  163|  5.15k|         return result;
  164|  5.15k|      }
  165|  5.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.15k|      {
   73|  5.15k|#if defined( __cpp_exceptions )
   74|  5.15k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.15k|            try {
   76|  5.15k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.15k|            }
   78|  5.15k|            catch( ... ) {
   79|  5.15k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.15k|               throw;
   81|  5.15k|            }
   82|  5.15k|         }
   83|  5.15k|         else {
   84|  5.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.15k|      {
   44|  5.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.15k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.66M|   {
  104|  5.66M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.66M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.66M|      }
  107|  5.66M|      else {
  108|  5.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.66M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.66M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.66M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.66M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.66M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.66M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.66M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.66M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.66M|         }
  128|       |
  129|  5.66M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.66M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.66M|         }
  132|       |
  133|  5.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.85k, False: 5.66M]
  ------------------
  143|  4.85k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.85k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.85k|            }
  146|  4.85k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.85k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.85k|            }
  149|  4.85k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.85k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.85k|            }
  152|  4.85k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.85k|            }
  155|  4.85k|         }
  156|  5.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.85k, False: 5.66M]
  ------------------
  157|  4.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.85k|         }
  159|  5.66M|         else {
  160|  5.66M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.66M|         }
  162|  5.66M|         (void)m( result );
  163|  5.66M|         return result;
  164|  5.66M|      }
  165|  5.66M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.66M|      {
   73|  5.66M|#if defined( __cpp_exceptions )
   74|  5.66M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.66M|            try {
   76|  5.66M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.66M|            }
   78|  5.66M|            catch( ... ) {
   79|  5.66M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.66M|               throw;
   81|  5.66M|            }
   82|  5.66M|         }
   83|  5.66M|         else {
   84|  5.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.66M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.66M|      {
   59|  5.66M|         return Rule::match( in );
   60|  5.66M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.66M|   {
  104|  5.66M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.66M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.66M|      }
  107|  5.66M|      else {
  108|  5.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.66M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.66M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.66M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.66M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.66M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.66M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.66M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.66M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.66M|         }
  128|       |
  129|  5.66M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.66M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.66M|         }
  132|       |
  133|  5.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.66M, False: 299]
  ------------------
  143|  5.66M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.66M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.66M|            }
  146|  5.66M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.66M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.66M|            }
  149|  5.66M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.66M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.66M|            }
  152|  5.66M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.66M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.66M|            }
  155|  5.66M|         }
  156|  5.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.66M, False: 299]
  ------------------
  157|  5.66M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.66M|         }
  159|    299|         else {
  160|    299|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    299|         }
  162|  5.66M|         (void)m( result );
  163|  5.66M|         return result;
  164|  5.66M|      }
  165|  5.66M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.66M|      {
   73|  5.66M|#if defined( __cpp_exceptions )
   74|  5.66M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.66M|            try {
   76|  5.66M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.66M|            }
   78|  5.66M|            catch( ... ) {
   79|  5.66M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.66M|               throw;
   81|  5.66M|            }
   82|  5.66M|         }
   83|  5.66M|         else {
   84|  5.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.66M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.66M|      {
   44|  5.66M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.66M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.66M|   {
  104|  5.66M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.66M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.66M|      }
  107|  5.66M|      else {
  108|  5.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.66M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.66M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.66M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.66M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.66M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.66M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.66M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.66M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.66M|         }
  128|       |
  129|  5.66M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.66M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.66M|         }
  132|       |
  133|  5.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 116k, False: 5.54M]
  ------------------
  143|   116k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   116k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   116k|            }
  146|   116k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   116k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   116k|            }
  149|   116k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   116k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   116k|            }
  152|   116k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   116k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   116k|            }
  155|   116k|         }
  156|  5.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 116k, False: 5.54M]
  ------------------
  157|   116k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   116k|         }
  159|  5.54M|         else {
  160|  5.54M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.54M|         }
  162|  5.66M|         (void)m( result );
  163|  5.66M|         return result;
  164|  5.66M|      }
  165|  5.66M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.66M|      {
   73|  5.66M|#if defined( __cpp_exceptions )
   74|  5.66M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.66M|            try {
   76|  5.66M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.66M|            }
   78|  5.66M|            catch( ... ) {
   79|  5.66M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.66M|               throw;
   81|  5.66M|            }
   82|  5.66M|         }
   83|  5.66M|         else {
   84|  5.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.66M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.66M|      {
   44|  5.66M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.66M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.66M|   {
  104|  5.66M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.66M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.66M|      }
  107|  5.66M|      else {
  108|  5.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.66M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.66M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.66M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.66M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.66M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.66M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.66M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.66M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.66M|         }
  128|       |
  129|  5.66M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.66M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.66M|         }
  132|       |
  133|  5.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 116k, False: 5.54M]
  ------------------
  143|   116k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   116k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   116k|            }
  146|   116k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   116k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   116k|            }
  149|   116k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   116k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   116k|            }
  152|   116k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   116k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   116k|            }
  155|   116k|         }
  156|  5.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 116k, False: 5.54M]
  ------------------
  157|   116k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   116k|         }
  159|  5.54M|         else {
  160|  5.54M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.54M|         }
  162|  5.66M|         (void)m( result );
  163|  5.66M|         return result;
  164|  5.66M|      }
  165|  5.66M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.66M|      {
   73|  5.66M|#if defined( __cpp_exceptions )
   74|  5.66M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.66M|            try {
   76|  5.66M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.66M|            }
   78|  5.66M|            catch( ... ) {
   79|  5.66M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.66M|               throw;
   81|  5.66M|            }
   82|  5.66M|         }
   83|  5.66M|         else {
   84|  5.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.66M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.66M|      {
   59|  5.66M|         return Rule::match( in );
   60|  5.66M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|   116k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   116k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   116k|      }
  107|   116k|      else {
  108|   116k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   116k|         using iterator_t = typename ParseInput::iterator_t;
  111|   116k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   116k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   116k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   116k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   116k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   116k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   116k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   116k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   116k|         }
  128|       |
  129|   116k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   116k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   116k|         }
  132|       |
  133|   116k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   116k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   116k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   116k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   116k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   116k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   116k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   116k|         if( result ) {
  143|   116k|            if constexpr( has_apply_void ) {
  144|   116k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   116k|            }
  146|   116k|            else if constexpr( has_apply_bool ) {
  147|   116k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   116k|            }
  149|   116k|            else if constexpr( has_apply0_void ) {
  150|   116k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   116k|            }
  152|   116k|            else if constexpr( has_apply0_bool ) {
  153|   116k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   116k|            }
  155|   116k|         }
  156|   116k|         if( result ) {
  157|   116k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   116k|         }
  159|   116k|         else {
  160|   116k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   116k|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   116k|      {
   44|   116k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   116k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|   116k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   116k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   116k|      }
  107|   116k|      else {
  108|   116k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   116k|         using iterator_t = typename ParseInput::iterator_t;
  111|   116k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   116k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   116k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   116k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   116k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   116k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   116k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   116k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   116k|         }
  128|       |
  129|   116k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   116k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   116k|         }
  132|       |
  133|   116k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   116k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   116k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   116k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   116k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   116k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   116k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   116k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 116k, False: 108]
  ------------------
  143|   116k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   116k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   116k|            }
  146|   116k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   116k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   116k|            }
  149|   116k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   116k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   116k|            }
  152|   116k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   116k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   116k|            }
  155|   116k|         }
  156|   116k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 116k, False: 108]
  ------------------
  157|   116k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   116k|         }
  159|    108|         else {
  160|    108|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    108|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   116k|      {
   73|   116k|#if defined( __cpp_exceptions )
   74|   116k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   116k|            try {
   76|   116k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   116k|            }
   78|   116k|            catch( ... ) {
   79|   116k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   116k|               throw;
   81|   116k|            }
   82|   116k|         }
   83|   116k|         else {
   84|   116k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   116k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   116k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   116k|      {
   44|   116k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   116k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|   116k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   116k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   116k|      }
  107|   116k|      else {
  108|   116k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   116k|         using iterator_t = typename ParseInput::iterator_t;
  111|   116k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   116k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   116k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   116k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   116k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   116k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   116k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   116k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   116k|         }
  128|       |
  129|   116k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   116k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   116k|         }
  132|       |
  133|   116k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   116k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   116k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   116k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   116k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   116k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   116k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   116k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.8k, False: 85.9k]
  ------------------
  143|  30.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.8k|            }
  146|  30.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.8k|            }
  149|  30.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.8k|            }
  152|  30.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.8k|            }
  155|  30.8k|         }
  156|   116k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.8k, False: 85.9k]
  ------------------
  157|  30.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.8k|         }
  159|  85.9k|         else {
  160|  85.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  85.9k|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   116k|      {
   73|   116k|#if defined( __cpp_exceptions )
   74|   116k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   116k|            try {
   76|   116k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   116k|            }
   78|   116k|            catch( ... ) {
   79|   116k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   116k|               throw;
   81|   116k|            }
   82|   116k|         }
   83|   116k|         else {
   84|   116k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   116k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   116k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   116k|      {
   44|   116k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   116k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|   116k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   116k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   116k|      }
  107|   116k|      else {
  108|   116k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   116k|         using iterator_t = typename ParseInput::iterator_t;
  111|   116k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   116k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   116k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   116k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   116k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   116k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   116k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   116k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   116k|         }
  128|       |
  129|   116k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   116k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   116k|         }
  132|       |
  133|   116k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   116k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   116k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   116k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   116k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   116k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   116k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   116k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.9k, False: 85.8k]
  ------------------
  143|  30.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.9k|            }
  146|  30.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.9k|            }
  149|  30.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.9k|            }
  152|  30.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.9k|            }
  155|  30.9k|         }
  156|   116k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.9k, False: 85.8k]
  ------------------
  157|  30.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.9k|         }
  159|  85.8k|         else {
  160|  85.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  85.8k|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   116k|      {
   73|   116k|#if defined( __cpp_exceptions )
   74|   116k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   116k|            try {
   76|   116k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   116k|            }
   78|   116k|            catch( ... ) {
   79|   116k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   116k|               throw;
   81|   116k|            }
   82|   116k|         }
   83|   116k|         else {
   84|   116k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   116k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   116k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   116k|      {
   59|   116k|         return Rule::match( in );
   60|   116k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  30.9k|   {
  104|  30.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.9k|      }
  107|  30.9k|      else {
  108|  30.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  30.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  30.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  30.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  30.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  30.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  30.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  30.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.9k|         }
  128|       |
  129|  30.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  30.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.9k|         }
  132|       |
  133|  30.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  30.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.9k|         if( result ) {
  143|  30.9k|            if constexpr( has_apply_void ) {
  144|  30.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.9k|            }
  146|  30.9k|            else if constexpr( has_apply_bool ) {
  147|  30.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.9k|            }
  149|  30.9k|            else if constexpr( has_apply0_void ) {
  150|  30.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.9k|            }
  152|  30.9k|            else if constexpr( has_apply0_bool ) {
  153|  30.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.9k|            }
  155|  30.9k|         }
  156|  30.9k|         if( result ) {
  157|  30.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.9k|         }
  159|  30.9k|         else {
  160|  30.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.9k|         }
  162|  30.9k|         (void)m( result );
  163|  30.9k|         return result;
  164|  30.9k|      }
  165|  30.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.9k|      {
   44|  30.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.9k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  30.9k|   {
  104|  30.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.9k|      }
  107|  30.9k|      else {
  108|  30.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  30.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  30.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  30.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  30.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  30.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  30.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  30.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.9k|         }
  128|       |
  129|  30.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  30.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.9k|         }
  132|       |
  133|  30.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  30.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.8k, False: 55]
  ------------------
  143|  30.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.8k|            }
  146|  30.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.8k|            }
  149|  30.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.8k|            }
  152|  30.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.8k|            }
  155|  30.8k|         }
  156|  30.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.8k, False: 55]
  ------------------
  157|  30.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.8k|         }
  159|     55|         else {
  160|     55|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     55|         }
  162|  30.9k|         (void)m( result );
  163|  30.9k|         return result;
  164|  30.9k|      }
  165|  30.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  30.9k|      {
   73|  30.9k|#if defined( __cpp_exceptions )
   74|  30.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  30.9k|            try {
   76|  30.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  30.9k|            }
   78|  30.9k|            catch( ... ) {
   79|  30.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  30.9k|               throw;
   81|  30.9k|            }
   82|  30.9k|         }
   83|  30.9k|         else {
   84|  30.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.9k|      {
   44|  30.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  61.8k|   {
  104|  61.8k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  61.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  61.8k|      }
  107|  61.8k|      else {
  108|  61.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  61.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  61.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  61.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  61.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  61.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  61.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  61.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  61.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  61.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  61.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  61.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  61.8k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  61.8k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  61.8k|         }
  128|       |
  129|  61.8k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  61.8k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  61.8k|         }
  132|       |
  133|  61.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  61.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  61.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  61.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  61.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  61.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  61.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  61.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 61.8k, False: 55]
  ------------------
  143|  61.8k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  61.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  61.8k|            }
  146|  61.8k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  61.8k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  61.8k|            }
  149|  61.8k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  61.8k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  61.8k|            }
  152|  61.8k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  61.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  61.8k|            }
  155|  61.8k|         }
  156|  61.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 61.8k, False: 55]
  ------------------
  157|  61.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  61.8k|         }
  159|     55|         else {
  160|     55|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     55|         }
  162|  61.8k|         (void)m( result );
  163|  61.8k|         return result;
  164|  61.8k|      }
  165|  61.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  61.8k|      {
   73|  61.8k|#if defined( __cpp_exceptions )
   74|  61.8k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  61.8k|            try {
   76|  61.8k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  61.8k|            }
   78|  61.8k|            catch( ... ) {
   79|  61.8k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  61.8k|               throw;
   81|  61.8k|            }
   82|  61.8k|         }
   83|  61.8k|         else {
   84|  61.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  61.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  61.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  61.8k|      {
   59|  61.8k|         return Rule::match( in );
   60|  61.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  85.8k|   {
  104|  85.8k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  85.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  85.8k|      }
  107|  85.8k|      else {
  108|  85.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  85.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  85.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  85.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  85.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  85.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  85.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  85.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  85.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  85.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  85.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  85.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  85.8k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  85.8k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  85.8k|         }
  128|       |
  129|  85.8k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  85.8k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  85.8k|         }
  132|       |
  133|  85.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  85.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  85.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  85.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  85.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  85.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  85.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  85.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.7k, False: 52.1k]
  ------------------
  143|  33.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  33.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  33.7k|            }
  146|  33.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  33.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  33.7k|            }
  149|  33.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  33.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  33.7k|            }
  152|  33.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  33.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.7k|            }
  155|  33.7k|         }
  156|  85.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.7k, False: 52.1k]
  ------------------
  157|  33.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.7k|         }
  159|  52.1k|         else {
  160|  52.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  52.1k|         }
  162|  85.8k|         (void)m( result );
  163|  85.8k|         return result;
  164|  85.8k|      }
  165|  85.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  85.8k|      {
   73|  85.8k|#if defined( __cpp_exceptions )
   74|  85.8k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  85.8k|            try {
   76|  85.8k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  85.8k|            }
   78|  85.8k|            catch( ... ) {
   79|  85.8k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  85.8k|               throw;
   81|  85.8k|            }
   82|  85.8k|         }
   83|  85.8k|         else {
   84|  85.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  85.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  85.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  85.8k|      {
   44|  85.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  85.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   138k|   {
  104|   138k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   138k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   138k|      }
  107|   138k|      else {
  108|   138k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   138k|         using iterator_t = typename ParseInput::iterator_t;
  111|   138k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   138k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   138k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   138k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   138k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   138k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   138k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   138k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   138k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   138k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   138k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   138k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   138k|         }
  128|       |
  129|   138k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   138k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   138k|         }
  132|       |
  133|   138k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   138k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   138k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   138k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   138k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   138k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   138k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   138k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 62.2k, False: 76.5k]
  ------------------
  143|  62.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  62.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  62.2k|            }
  146|  62.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  62.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  62.2k|            }
  149|  62.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  62.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  62.2k|            }
  152|  62.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  62.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  62.2k|            }
  155|  62.2k|         }
  156|   138k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 62.2k, False: 76.5k]
  ------------------
  157|  62.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  62.2k|         }
  159|  76.5k|         else {
  160|  76.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  76.5k|         }
  162|   138k|         (void)m( result );
  163|   138k|         return result;
  164|   138k|      }
  165|   138k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   138k|      {
   73|   138k|#if defined( __cpp_exceptions )
   74|   138k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   138k|            try {
   76|   138k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   138k|            }
   78|   138k|            catch( ... ) {
   79|   138k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   138k|               throw;
   81|   138k|            }
   82|   138k|         }
   83|   138k|         else {
   84|   138k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   138k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   138k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   138k|      {
   59|   138k|         return Rule::match( in );
   60|   138k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  33.7k|   {
  104|  33.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  33.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  33.7k|      }
  107|  33.7k|      else {
  108|  33.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  33.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  33.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  33.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  33.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  33.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  33.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  33.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  33.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  33.7k|         }
  128|       |
  129|  33.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  33.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  33.7k|         }
  132|       |
  133|  33.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  33.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.7k|         if( result ) {
  143|  33.7k|            if constexpr( has_apply_void ) {
  144|  33.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  33.7k|            }
  146|  33.7k|            else if constexpr( has_apply_bool ) {
  147|  33.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  33.7k|            }
  149|  33.7k|            else if constexpr( has_apply0_void ) {
  150|  33.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  33.7k|            }
  152|  33.7k|            else if constexpr( has_apply0_bool ) {
  153|  33.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.7k|            }
  155|  33.7k|         }
  156|  33.7k|         if( result ) {
  157|  33.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.7k|         }
  159|  33.7k|         else {
  160|  33.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.7k|         }
  162|  33.7k|         (void)m( result );
  163|  33.7k|         return result;
  164|  33.7k|      }
  165|  33.7k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.7k|      {
   44|  33.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.7k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  33.7k|   {
  104|  33.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  33.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  33.7k|      }
  107|  33.7k|      else {
  108|  33.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  33.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  33.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  33.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  33.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  33.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  33.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  33.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  33.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  33.7k|         }
  128|       |
  129|  33.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  33.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  33.7k|         }
  132|       |
  133|  33.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  33.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.7k, False: 0]
  ------------------
  143|  33.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  33.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  33.7k|            }
  146|  33.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  33.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  33.7k|            }
  149|  33.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  33.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  33.7k|            }
  152|  33.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  33.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.7k|            }
  155|  33.7k|         }
  156|  33.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.7k, False: 0]
  ------------------
  157|  33.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  33.7k|         (void)m( result );
  163|  33.7k|         return result;
  164|  33.7k|      }
  165|  33.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  33.7k|      {
   73|  33.7k|#if defined( __cpp_exceptions )
   74|  33.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  33.7k|            try {
   76|  33.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  33.7k|            }
   78|  33.7k|            catch( ... ) {
   79|  33.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  33.7k|               throw;
   81|  33.7k|            }
   82|  33.7k|         }
   83|  33.7k|         else {
   84|  33.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.7k|      {
   44|  33.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  52.1k|   {
  104|  52.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  52.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  52.1k|      }
  107|  52.1k|      else {
  108|  52.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  52.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  52.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  52.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  52.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  52.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  52.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  52.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  52.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  52.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  52.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  52.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  52.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  52.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  52.1k|         }
  128|       |
  129|  52.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  52.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  52.1k|         }
  132|       |
  133|  52.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  52.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  52.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  52.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  52.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  52.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  52.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  52.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 50.9k, False: 1.25k]
  ------------------
  143|  50.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  50.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  50.9k|            }
  146|  50.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  50.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  50.9k|            }
  149|  50.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  50.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  50.9k|            }
  152|  50.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  50.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  50.9k|            }
  155|  50.9k|         }
  156|  52.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 50.9k, False: 1.25k]
  ------------------
  157|  50.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  50.9k|         }
  159|  1.25k|         else {
  160|  1.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.25k|         }
  162|  52.1k|         (void)m( result );
  163|  52.1k|         return result;
  164|  52.1k|      }
  165|  52.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  52.1k|      {
   73|  52.1k|#if defined( __cpp_exceptions )
   74|  52.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  52.1k|            try {
   76|  52.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  52.1k|            }
   78|  52.1k|            catch( ... ) {
   79|  52.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  52.1k|               throw;
   81|  52.1k|            }
   82|  52.1k|         }
   83|  52.1k|         else {
   84|  52.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  52.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  52.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  52.1k|      {
   59|  52.1k|         return Rule::match( in );
   60|  52.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.25k|   {
  104|  1.25k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.25k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.25k|      }
  107|  1.25k|      else {
  108|  1.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.25k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.25k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.25k|         }
  128|       |
  129|  1.25k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.25k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.25k|         }
  132|       |
  133|  1.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.25k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.19k, False: 53]
  ------------------
  143|  1.19k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.19k|            }
  146|  1.19k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.19k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.19k|            }
  149|  1.19k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.19k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.19k|            }
  152|  1.19k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.19k|            }
  155|  1.19k|         }
  156|  1.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.19k, False: 53]
  ------------------
  157|  1.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.19k|         }
  159|     53|         else {
  160|     53|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     53|         }
  162|  1.25k|         (void)m( result );
  163|  1.25k|         return result;
  164|  1.25k|      }
  165|  1.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.25k|      {
   73|  1.25k|#if defined( __cpp_exceptions )
   74|  1.25k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.25k|            try {
   76|  1.25k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.25k|            }
   78|  1.25k|            catch( ... ) {
   79|  1.25k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.25k|               throw;
   81|  1.25k|            }
   82|  1.25k|         }
   83|  1.25k|         else {
   84|  1.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.25k|      {
   59|  1.25k|         return Rule::match( in );
   60|  1.25k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.54M|   {
  104|  5.54M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.54M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.54M|      }
  107|  5.54M|      else {
  108|  5.54M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.54M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.54M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.54M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.54M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.54M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.54M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.54M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.54M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.54M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.54M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.54M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.54M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.54M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.54M|         }
  128|       |
  129|  5.54M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.54M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.54M|         }
  132|       |
  133|  5.54M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.54M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.54M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.54M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.54M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.54M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.54M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.54M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.54M, False: 191]
  ------------------
  143|  5.54M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  5.54M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  5.54M|            }
  146|  5.54M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  5.54M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  5.54M|            }
  149|  5.54M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  5.54M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  5.54M|            }
  152|  5.54M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  5.54M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.54M|            }
  155|  5.54M|         }
  156|  5.54M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.54M, False: 191]
  ------------------
  157|  5.54M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.54M|         }
  159|    191|         else {
  160|    191|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    191|         }
  162|  5.54M|         (void)m( result );
  163|  5.54M|         return result;
  164|  5.54M|      }
  165|  5.54M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.54M|      {
   73|  5.54M|#if defined( __cpp_exceptions )
   74|  5.54M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.54M|            try {
   76|  5.54M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.54M|            }
   78|  5.54M|            catch( ... ) {
   79|  5.54M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.54M|               throw;
   81|  5.54M|            }
   82|  5.54M|         }
   83|  5.54M|         else {
   84|  5.54M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.54M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.54M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.54M|      {
   59|  5.54M|         return Rule::match( in );
   60|  5.54M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  18.1k|   {
  104|  18.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  18.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  18.1k|      }
  107|  18.1k|      else {
  108|  18.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  18.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  18.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  18.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  18.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  18.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  18.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  18.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  18.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  18.1k|         }
  128|       |
  129|  18.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  18.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  18.1k|         }
  132|       |
  133|  18.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  18.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  18.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.19k, False: 13.9k]
  ------------------
  143|  4.19k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.19k|            }
  146|  4.19k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.19k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.19k|            }
  149|  4.19k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.19k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.19k|            }
  152|  4.19k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.19k|            }
  155|  4.19k|         }
  156|  18.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.19k, False: 13.9k]
  ------------------
  157|  4.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.19k|         }
  159|  13.9k|         else {
  160|  13.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.9k|         }
  162|  18.1k|         (void)m( result );
  163|  18.1k|         return result;
  164|  18.1k|      }
  165|  18.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  18.1k|      {
   73|  18.1k|#if defined( __cpp_exceptions )
   74|  18.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  18.1k|            try {
   76|  18.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  18.1k|            }
   78|  18.1k|            catch( ... ) {
   79|  18.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  18.1k|               throw;
   81|  18.1k|            }
   82|  18.1k|         }
   83|  18.1k|         else {
   84|  18.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  18.1k|      {
   44|  18.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  18.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  18.1k|   {
  104|  18.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  18.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  18.1k|      }
  107|  18.1k|      else {
  108|  18.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  18.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  18.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  18.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  18.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  18.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  18.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  18.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  18.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  18.1k|         }
  128|       |
  129|  18.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  18.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  18.1k|         }
  132|       |
  133|  18.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  18.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  18.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.19k, False: 13.9k]
  ------------------
  143|  4.19k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.19k|            }
  146|  4.19k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.19k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.19k|            }
  149|  4.19k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.19k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.19k|            }
  152|  4.19k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.19k|            }
  155|  4.19k|         }
  156|  18.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.19k, False: 13.9k]
  ------------------
  157|  4.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.19k|         }
  159|  13.9k|         else {
  160|  13.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.9k|         }
  162|  18.1k|         (void)m( result );
  163|  18.1k|         return result;
  164|  18.1k|      }
  165|  18.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_6str_ifENS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  18.1k|      {
   73|  18.1k|#if defined( __cpp_exceptions )
   74|  18.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  18.1k|            try {
   76|  18.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  18.1k|            }
   78|  18.1k|            catch( ... ) {
   79|  18.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  18.1k|               throw;
   81|  18.1k|            }
   82|  18.1k|         }
   83|  18.1k|         else {
   84|  18.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_6str_ifENS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  18.1k|      {
   44|  18.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  18.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  18.1k|   {
  104|  18.1k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  18.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  18.1k|      }
  107|  18.1k|      else {
  108|  18.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  18.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  18.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  18.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  18.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  18.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  18.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  18.1k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  18.1k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  18.1k|         }
  128|       |
  129|  18.1k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  18.1k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  18.1k|         }
  132|       |
  133|  18.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  18.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  18.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.79k, False: 11.3k]
  ------------------
  143|  6.79k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.79k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.79k|            }
  146|  6.79k|            else if constexpr( has_apply_bool ) {
  147|  6.79k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.79k|            }
  149|  6.79k|            else if constexpr( has_apply0_void ) {
  150|  6.79k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.79k|            }
  152|  6.79k|            else if constexpr( has_apply0_bool ) {
  153|  6.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.79k|            }
  155|  6.79k|         }
  156|  18.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.78k, False: 11.3k]
  ------------------
  157|  6.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.78k|         }
  159|  11.3k|         else {
  160|  11.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.3k|         }
  162|  18.1k|         (void)m( result );
  163|  18.1k|         return result;
  164|  18.1k|      }
  165|  18.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  18.1k|      {
   73|  18.1k|#if defined( __cpp_exceptions )
   74|  18.1k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  18.1k|            try {
   76|  18.1k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  18.1k|            }
   78|  18.1k|            catch( ... ) {
   79|  18.1k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  18.1k|               throw;
   81|  18.1k|            }
   82|  18.1k|         }
   83|  18.1k|         else {
   84|  18.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  18.1k|      {
   59|  18.1k|         return Rule::match( in );
   60|  18.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   295k|   {
  104|   295k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   295k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   295k|      }
  107|   295k|      else {
  108|   295k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   295k|         using iterator_t = typename ParseInput::iterator_t;
  111|   295k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   295k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   295k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   295k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   295k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   295k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   295k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   295k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   295k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   295k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   295k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   295k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   295k|         }
  128|       |
  129|   295k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   295k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   295k|         }
  132|       |
  133|   295k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   295k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   295k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   295k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   295k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   295k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   295k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   295k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 293k, False: 2.46k]
  ------------------
  143|   293k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   293k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   293k|            }
  146|   293k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   293k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   293k|            }
  149|   293k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   293k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   293k|            }
  152|   293k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   293k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   293k|            }
  155|   293k|         }
  156|   295k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 293k, False: 2.46k]
  ------------------
  157|   293k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   293k|         }
  159|  2.46k|         else {
  160|  2.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.46k|         }
  162|   295k|         (void)m( result );
  163|   295k|         return result;
  164|   295k|      }
  165|   295k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   295k|      {
   73|   295k|#if defined( __cpp_exceptions )
   74|   295k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   295k|            try {
   76|   295k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   295k|            }
   78|   295k|            catch( ... ) {
   79|   295k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   295k|               throw;
   81|   295k|            }
   82|   295k|         }
   83|   295k|         else {
   84|   295k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   295k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   295k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   295k|      {
   44|   295k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   295k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   295k|   {
  104|   295k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   295k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   295k|      }
  107|   295k|      else {
  108|   295k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   295k|         using iterator_t = typename ParseInput::iterator_t;
  111|   295k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   295k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   295k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   295k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   295k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   295k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   295k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   295k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   295k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   295k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   295k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   295k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   295k|         }
  128|       |
  129|   295k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   295k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   295k|         }
  132|       |
  133|   295k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   295k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   295k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   295k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   295k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   295k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   295k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   295k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 293k, False: 2.46k]
  ------------------
  143|   293k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   293k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   293k|            }
  146|   293k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   293k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   293k|            }
  149|   293k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   293k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   293k|            }
  152|   293k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   293k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   293k|            }
  155|   293k|         }
  156|   295k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 293k, False: 2.46k]
  ------------------
  157|   293k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   293k|         }
  159|  2.46k|         else {
  160|  2.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.46k|         }
  162|   295k|         (void)m( result );
  163|   295k|         return result;
  164|   295k|      }
  165|   295k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   295k|      {
   73|   295k|#if defined( __cpp_exceptions )
   74|   295k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   295k|            try {
   76|   295k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   295k|            }
   78|   295k|            catch( ... ) {
   79|   295k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   295k|               throw;
   81|   295k|            }
   82|   295k|         }
   83|   295k|         else {
   84|   295k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   295k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   295k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   295k|      {
   59|   295k|         return Rule::match( in );
   60|   295k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   323k|   {
  104|   323k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   323k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   323k|      }
  107|   323k|      else {
  108|   323k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   323k|         using iterator_t = typename ParseInput::iterator_t;
  111|   323k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   323k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   323k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   323k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   323k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   323k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   323k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   323k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   323k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   323k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   323k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   323k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   323k|         }
  128|       |
  129|   323k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   323k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   323k|         }
  132|       |
  133|   323k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   323k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   323k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   323k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   323k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   323k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   323k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   323k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 22.2k, False: 300k]
  ------------------
  143|  22.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  22.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  22.2k|            }
  146|  22.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  22.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  22.2k|            }
  149|  22.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  22.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  22.2k|            }
  152|  22.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  22.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  22.2k|            }
  155|  22.2k|         }
  156|   323k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 22.2k, False: 300k]
  ------------------
  157|  22.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  22.2k|         }
  159|   300k|         else {
  160|   300k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   300k|         }
  162|   323k|         (void)m( result );
  163|   323k|         return result;
  164|   323k|      }
  165|   323k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   323k|      {
   73|   323k|#if defined( __cpp_exceptions )
   74|   323k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   323k|            try {
   76|   323k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   323k|            }
   78|   323k|            catch( ... ) {
   79|   323k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   323k|               throw;
   81|   323k|            }
   82|   323k|         }
   83|   323k|         else {
   84|   323k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   323k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   323k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   323k|      {
   59|   323k|         return Rule::match( in );
   60|   323k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.19k, False: 2.57k]
  ------------------
  143|  4.19k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.19k|            }
  146|  4.19k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.19k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.19k|            }
  149|  4.19k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.19k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.19k|            }
  152|  4.19k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.19k|            }
  155|  4.19k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.19k, False: 2.57k]
  ------------------
  157|  4.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.19k|         }
  159|  2.57k|         else {
  160|  2.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.57k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.75k, False: 4.01k]
  ------------------
  143|  2.75k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.75k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.75k|            }
  146|  2.75k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.75k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.75k|            }
  149|  2.75k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.75k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.75k|            }
  152|  2.75k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.75k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.75k|            }
  155|  2.75k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.75k, False: 4.01k]
  ------------------
  157|  2.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.75k|         }
  159|  4.01k|         else {
  160|  4.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.01k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.76k, False: 0]
  ------------------
  143|  6.76k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.76k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.76k|            }
  146|  6.76k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.76k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.76k|            }
  149|  6.76k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.76k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.76k|            }
  152|  6.76k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.76k|            }
  155|  6.76k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.76k, False: 0]
  ------------------
  157|  6.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.76k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  143|  6.76k|            if constexpr( has_apply_void ) {
  144|  6.76k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.76k|            }
  146|  6.76k|            else if constexpr( has_apply_bool ) {
  147|  6.76k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.76k|            }
  149|  6.76k|            else if constexpr( has_apply0_void ) {
  150|  6.76k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.76k|            }
  152|  6.76k|            else if constexpr( has_apply0_bool ) {
  153|  6.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.76k|            }
  155|  6.76k|         }
  156|  6.76k|         if( result ) {
  157|  6.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.76k|         }
  159|  6.76k|         else {
  160|  6.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.76k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, False: 4.89k]
  ------------------
  143|  1.86k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.86k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.86k|            }
  146|  1.86k|            else if constexpr( has_apply_bool ) {
  147|  1.86k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.86k|            }
  149|  1.86k|            else if constexpr( has_apply0_void ) {
  150|  1.86k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.86k|            }
  152|  1.86k|            else if constexpr( has_apply0_bool ) {
  153|  1.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.86k|            }
  155|  1.86k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 4.89k]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|  4.89k|         else {
  160|  4.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.89k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 332, False: 6.43k]
  ------------------
  143|    332|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    332|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    332|            }
  146|    332|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    332|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    332|            }
  149|    332|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    332|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    332|            }
  152|    332|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    332|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    332|            }
  155|    332|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 332, False: 6.43k]
  ------------------
  157|    332|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    332|         }
  159|  6.43k|         else {
  160|  6.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.43k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.76k|      {
   59|  6.76k|         return Rule::match( in );
   60|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.43k|   {
  104|  6.43k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.43k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.43k|      }
  107|  6.43k|      else {
  108|  6.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.43k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.43k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.43k|         }
  128|       |
  129|  6.43k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.43k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.43k|         }
  132|       |
  133|  6.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.43k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 404, False: 6.02k]
  ------------------
  143|    404|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    404|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    404|            }
  146|    404|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    404|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    404|            }
  149|    404|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    404|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    404|            }
  152|    404|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    404|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    404|            }
  155|    404|         }
  156|  6.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 404, False: 6.02k]
  ------------------
  157|    404|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    404|         }
  159|  6.02k|         else {
  160|  6.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.02k|         }
  162|  6.43k|         (void)m( result );
  163|  6.43k|         return result;
  164|  6.43k|      }
  165|  6.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.43k|      {
   73|  6.43k|#if defined( __cpp_exceptions )
   74|  6.43k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.43k|            try {
   76|  6.43k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.43k|            }
   78|  6.43k|            catch( ... ) {
   79|  6.43k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.43k|               throw;
   81|  6.43k|            }
   82|  6.43k|         }
   83|  6.43k|         else {
   84|  6.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.43k|      {
   59|  6.43k|         return Rule::match( in );
   60|  6.43k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.02k|   {
  104|  6.02k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.02k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.02k|      }
  107|  6.02k|      else {
  108|  6.02k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.02k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.02k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.02k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.02k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.02k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.02k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.02k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.02k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.02k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.02k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.02k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.02k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.02k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.02k|         }
  128|       |
  129|  6.02k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.02k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.02k|         }
  132|       |
  133|  6.02k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.02k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.02k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.02k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.02k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.02k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.02k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.02k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 200, False: 5.82k]
  ------------------
  143|    200|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    200|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    200|            }
  146|    200|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    200|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    200|            }
  149|    200|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    200|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    200|            }
  152|    200|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    200|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    200|            }
  155|    200|         }
  156|  6.02k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 200, False: 5.82k]
  ------------------
  157|    200|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    200|         }
  159|  5.82k|         else {
  160|  5.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.82k|         }
  162|  6.02k|         (void)m( result );
  163|  6.02k|         return result;
  164|  6.02k|      }
  165|  6.02k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.02k|      {
   73|  6.02k|#if defined( __cpp_exceptions )
   74|  6.02k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.02k|            try {
   76|  6.02k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.02k|            }
   78|  6.02k|            catch( ... ) {
   79|  6.02k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.02k|               throw;
   81|  6.02k|            }
   82|  6.02k|         }
   83|  6.02k|         else {
   84|  6.02k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.02k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.02k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.02k|      {
   59|  6.02k|         return Rule::match( in );
   60|  6.02k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.82k|   {
  104|  5.82k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.82k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.82k|      }
  107|  5.82k|      else {
  108|  5.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.82k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.82k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.82k|         }
  128|       |
  129|  5.82k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.82k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.82k|         }
  132|       |
  133|  5.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.82k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 226, False: 5.60k]
  ------------------
  143|    226|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    226|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    226|            }
  146|    226|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    226|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    226|            }
  149|    226|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    226|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    226|            }
  152|    226|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    226|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    226|            }
  155|    226|         }
  156|  5.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 226, False: 5.60k]
  ------------------
  157|    226|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    226|         }
  159|  5.60k|         else {
  160|  5.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.60k|         }
  162|  5.82k|         (void)m( result );
  163|  5.82k|         return result;
  164|  5.82k|      }
  165|  5.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.82k|      {
   73|  5.82k|#if defined( __cpp_exceptions )
   74|  5.82k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.82k|            try {
   76|  5.82k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.82k|            }
   78|  5.82k|            catch( ... ) {
   79|  5.82k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.82k|               throw;
   81|  5.82k|            }
   82|  5.82k|         }
   83|  5.82k|         else {
   84|  5.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.82k|      {
   59|  5.82k|         return Rule::match( in );
   60|  5.82k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.60k|   {
  104|  5.60k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.60k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.60k|      }
  107|  5.60k|      else {
  108|  5.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.60k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.60k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.60k|         }
  128|       |
  129|  5.60k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.60k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.60k|         }
  132|       |
  133|  5.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.60k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 512, False: 5.08k]
  ------------------
  143|    512|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    512|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    512|            }
  146|    512|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    512|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    512|            }
  149|    512|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    512|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    512|            }
  152|    512|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    512|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    512|            }
  155|    512|         }
  156|  5.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 512, False: 5.08k]
  ------------------
  157|    512|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    512|         }
  159|  5.08k|         else {
  160|  5.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.08k|         }
  162|  5.60k|         (void)m( result );
  163|  5.60k|         return result;
  164|  5.60k|      }
  165|  5.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.60k|      {
   73|  5.60k|#if defined( __cpp_exceptions )
   74|  5.60k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.60k|            try {
   76|  5.60k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.60k|            }
   78|  5.60k|            catch( ... ) {
   79|  5.60k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.60k|               throw;
   81|  5.60k|            }
   82|  5.60k|         }
   83|  5.60k|         else {
   84|  5.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.60k|      {
   59|  5.60k|         return Rule::match( in );
   60|  5.60k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.08k|   {
  104|  5.08k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  5.08k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  5.08k|      }
  107|  5.08k|      else {
  108|  5.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.08k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  5.08k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  5.08k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  5.08k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  5.08k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  5.08k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  5.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.08k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  5.08k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  5.08k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  5.08k|         }
  128|       |
  129|  5.08k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  5.08k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  5.08k|         }
  132|       |
  133|  5.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.08k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  5.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 4.89k]
  ------------------
  143|    194|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    194|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    194|            }
  146|    194|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    194|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    194|            }
  149|    194|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    194|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    194|            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  5.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 4.89k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  4.89k|         else {
  160|  4.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.89k|         }
  162|  5.08k|         (void)m( result );
  163|  5.08k|         return result;
  164|  5.08k|      }
  165|  5.08k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.08k|      {
   73|  5.08k|#if defined( __cpp_exceptions )
   74|  5.08k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  5.08k|            try {
   76|  5.08k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  5.08k|            }
   78|  5.08k|            catch( ... ) {
   79|  5.08k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  5.08k|               throw;
   81|  5.08k|            }
   82|  5.08k|         }
   83|  5.08k|         else {
   84|  5.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.08k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.08k|      {
   59|  5.08k|         return Rule::match( in );
   60|  5.08k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.76k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.76k|      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.76k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.76k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.76k|         }
  128|       |
  129|  6.76k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.76k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.76k|         }
  132|       |
  133|  6.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.46k, False: 2.30k]
  ------------------
  143|  4.46k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.46k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.46k|            }
  146|  4.46k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.46k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.46k|            }
  149|  4.46k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.46k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.46k|            }
  152|  4.46k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.46k|            }
  155|  4.46k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.46k, False: 2.30k]
  ------------------
  157|  4.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.46k|         }
  159|  2.30k|         else {
  160|  2.30k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.30k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|  6.76k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.76k|            try {
   76|  6.76k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.76k|            }
   78|  6.76k|            catch( ... ) {
   79|  6.76k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.76k|               throw;
   81|  6.76k|            }
   82|  6.76k|         }
   83|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.76k|      {
   59|  6.76k|         return Rule::match( in );
   60|  6.76k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.71k|   {
  104|  7.71k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.71k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.71k|      }
  107|  7.71k|      else {
  108|  7.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.71k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.71k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.71k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.71k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.71k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.71k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.71k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.71k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.71k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.71k|         }
  128|       |
  129|  7.71k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.71k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.71k|         }
  132|       |
  133|  7.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.71k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.71k, False: 0]
  ------------------
  143|  7.71k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.71k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.71k|            }
  146|  7.71k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.71k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.71k|            }
  149|  7.71k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.71k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.71k|            }
  152|  7.71k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.71k|            }
  155|  7.71k|         }
  156|  7.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.71k, False: 0]
  ------------------
  157|  7.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.71k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  7.71k|         (void)m( result );
  163|  7.71k|         return result;
  164|  7.71k|      }
  165|  7.71k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  7.71k|      {
   73|  7.71k|#if defined( __cpp_exceptions )
   74|  7.71k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.71k|            try {
   76|  7.71k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.71k|            }
   78|  7.71k|            catch( ... ) {
   79|  7.71k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.71k|               throw;
   81|  7.71k|            }
   82|  7.71k|         }
   83|  7.71k|         else {
   84|  7.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.71k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.71k|      {
   44|  7.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.71k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.46k|   {
  104|  4.46k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.46k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.46k|      }
  107|  4.46k|      else {
  108|  4.46k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.46k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.46k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.46k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.46k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.46k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.46k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.46k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.46k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.46k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.46k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.46k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.46k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.46k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.46k|         }
  128|       |
  129|  4.46k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.46k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.46k|         }
  132|       |
  133|  4.46k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.46k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.46k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.46k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.46k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.46k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.46k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.46k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.25k, False: 1.20k]
  ------------------
  143|  3.25k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.25k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.25k|            }
  146|  3.25k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.25k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.25k|            }
  149|  3.25k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.25k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.25k|            }
  152|  3.25k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.25k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.25k|            }
  155|  3.25k|         }
  156|  4.46k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.25k, False: 1.20k]
  ------------------
  157|  3.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.25k|         }
  159|  1.20k|         else {
  160|  1.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.20k|         }
  162|  4.46k|         (void)m( result );
  163|  4.46k|         return result;
  164|  4.46k|      }
  165|  4.46k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.46k|      {
   73|  4.46k|#if defined( __cpp_exceptions )
   74|  4.46k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.46k|            try {
   76|  4.46k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.46k|            }
   78|  4.46k|            catch( ... ) {
   79|  4.46k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.46k|               throw;
   81|  4.46k|            }
   82|  4.46k|         }
   83|  4.46k|         else {
   84|  4.46k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.46k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.46k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.46k|      {
   44|  4.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.46k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.32k|   {
  104|  4.32k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.32k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.32k|      }
  107|  4.32k|      else {
  108|  4.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.32k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.32k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.32k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.32k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.32k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.32k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.32k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.32k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.32k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.32k|         }
  128|       |
  129|  4.32k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.32k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.32k|         }
  132|       |
  133|  4.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.32k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.32k|         if( result ) {
  143|  4.32k|            if constexpr( has_apply_void ) {
  144|  4.32k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.32k|            }
  146|  4.32k|            else if constexpr( has_apply_bool ) {
  147|  4.32k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.32k|            }
  149|  4.32k|            else if constexpr( has_apply0_void ) {
  150|  4.32k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.32k|            }
  152|  4.32k|            else if constexpr( has_apply0_bool ) {
  153|  4.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.32k|            }
  155|  4.32k|         }
  156|  4.32k|         if( result ) {
  157|  4.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.32k|         }
  159|  4.32k|         else {
  160|  4.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.32k|         }
  162|  4.32k|         (void)m( result );
  163|  4.32k|         return result;
  164|  4.32k|      }
  165|  4.32k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.32k|      {
   44|  4.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.32k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   286k|   {
  104|   286k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   286k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   286k|      }
  107|   286k|      else {
  108|   286k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   286k|         using iterator_t = typename ParseInput::iterator_t;
  111|   286k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   286k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   286k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   286k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   286k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   286k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   286k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   286k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   286k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   286k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   286k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   286k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   286k|         }
  128|       |
  129|   286k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   286k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   286k|         }
  132|       |
  133|   286k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   286k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   286k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   286k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   286k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   286k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   286k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   286k|         if( result ) {
  143|   286k|            if constexpr( has_apply_void ) {
  144|   286k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   286k|            }
  146|   286k|            else if constexpr( has_apply_bool ) {
  147|   286k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   286k|            }
  149|   286k|            else if constexpr( has_apply0_void ) {
  150|   286k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   286k|            }
  152|   286k|            else if constexpr( has_apply0_bool ) {
  153|   286k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   286k|            }
  155|   286k|         }
  156|   286k|         if( result ) {
  157|   286k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   286k|         }
  159|   286k|         else {
  160|   286k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   286k|         }
  162|   286k|         (void)m( result );
  163|   286k|         return result;
  164|   286k|      }
  165|   286k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   286k|      {
   44|   286k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   286k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.25k|   {
  104|  3.25k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.25k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.25k|      }
  107|  3.25k|      else {
  108|  3.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.25k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.25k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.25k|         }
  128|       |
  129|  3.25k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.25k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.25k|         }
  132|       |
  133|  3.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.25k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.75k, False: 507]
  ------------------
  143|  2.75k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.75k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.75k|            }
  146|  2.75k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.75k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.75k|            }
  149|  2.75k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.75k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.75k|            }
  152|  2.75k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.75k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.75k|            }
  155|  2.75k|         }
  156|  3.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.75k, False: 507]
  ------------------
  157|  2.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.75k|         }
  159|    507|         else {
  160|    507|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    507|         }
  162|  3.25k|         (void)m( result );
  163|  3.25k|         return result;
  164|  3.25k|      }
  165|  3.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.25k|      {
   73|  3.25k|#if defined( __cpp_exceptions )
   74|  3.25k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.25k|            try {
   76|  3.25k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.25k|            }
   78|  3.25k|            catch( ... ) {
   79|  3.25k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.25k|               throw;
   81|  3.25k|            }
   82|  3.25k|         }
   83|  3.25k|         else {
   84|  3.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.25k|      {
   59|  3.25k|         return Rule::match( in );
   60|  3.25k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   291k|   {
  104|   291k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   291k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   291k|      }
  107|   291k|      else {
  108|   291k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   291k|         using iterator_t = typename ParseInput::iterator_t;
  111|   291k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   291k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   291k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   291k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   291k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   291k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   291k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   291k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   291k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   291k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   291k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   291k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   291k|         }
  128|       |
  129|   291k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   291k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   291k|         }
  132|       |
  133|   291k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   291k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   291k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   291k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   291k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   291k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   291k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   291k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 289k, False: 1.93k]
  ------------------
  143|   289k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   289k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   289k|            }
  146|   289k|            else if constexpr( has_apply_bool ) {
  147|   289k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   289k|            }
  149|   289k|            else if constexpr( has_apply0_void ) {
  150|   289k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   289k|            }
  152|   289k|            else if constexpr( has_apply0_bool ) {
  153|   289k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   289k|            }
  155|   289k|         }
  156|   291k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 288k, False: 3.51k]
  ------------------
  157|   288k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   288k|         }
  159|  3.51k|         else {
  160|  3.51k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.51k|         }
  162|   291k|         (void)m( result );
  163|   291k|         return result;
  164|   291k|      }
  165|   291k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   291k|      {
   73|   291k|#if defined( __cpp_exceptions )
   74|   291k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   291k|            try {
   76|   291k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   291k|            }
   78|   291k|            catch( ... ) {
   79|   291k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   291k|               throw;
   81|   291k|            }
   82|   291k|         }
   83|   291k|         else {
   84|   291k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   291k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   291k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   291k|      {
   44|   291k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   291k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   291k|   {
  104|   291k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   291k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   291k|      }
  107|   291k|      else {
  108|   291k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   291k|         using iterator_t = typename ParseInput::iterator_t;
  111|   291k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   291k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   291k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   291k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   291k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   291k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   291k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   291k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   291k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   291k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   291k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   291k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   291k|         }
  128|       |
  129|   291k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   291k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   291k|         }
  132|       |
  133|   291k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   291k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   291k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   291k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   291k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   291k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   291k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   291k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 291k, False: 0]
  ------------------
  143|   291k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   291k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   291k|            }
  146|   291k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   291k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   291k|            }
  149|   291k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   291k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   291k|            }
  152|   291k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   291k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   291k|            }
  155|   291k|         }
  156|   291k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 291k, False: 0]
  ------------------
  157|   291k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   291k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   291k|         (void)m( result );
  163|   291k|         return result;
  164|   291k|      }
  165|   291k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   291k|      {
   73|   291k|#if defined( __cpp_exceptions )
   74|   291k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   291k|            try {
   76|   291k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   291k|            }
   78|   291k|            catch( ... ) {
   79|   291k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   291k|               throw;
   81|   291k|            }
   82|   291k|         }
   83|   291k|         else {
   84|   291k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   291k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   291k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   291k|      {
   44|   291k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   291k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   291k|   {
  104|   291k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   291k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   291k|      }
  107|   291k|      else {
  108|   291k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   291k|         using iterator_t = typename ParseInput::iterator_t;
  111|   291k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   291k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   291k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   291k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   291k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   291k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   291k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   291k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   291k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   291k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   291k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   291k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   291k|         }
  128|       |
  129|   291k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   291k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   291k|         }
  132|       |
  133|   291k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   291k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   291k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   291k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   291k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   291k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   291k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   291k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.24k, False: 290k]
  ------------------
  143|  1.24k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.24k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.24k|            }
  146|  1.24k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.24k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.24k|            }
  149|  1.24k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.24k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.24k|            }
  152|  1.24k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.24k|            }
  155|  1.24k|         }
  156|   291k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.24k, False: 290k]
  ------------------
  157|  1.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.24k|         }
  159|   290k|         else {
  160|   290k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   290k|         }
  162|   291k|         (void)m( result );
  163|   291k|         return result;
  164|   291k|      }
  165|   291k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   291k|      {
   73|   291k|#if defined( __cpp_exceptions )
   74|   291k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   291k|            try {
   76|   291k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   291k|            }
   78|   291k|            catch( ... ) {
   79|   291k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   291k|               throw;
   81|   291k|            }
   82|   291k|         }
   83|   291k|         else {
   84|   291k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   291k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   291k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   291k|      {
   59|   291k|         return Rule::match( in );
   60|   291k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   291k|   {
  104|   291k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   291k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   291k|      }
  107|   291k|      else {
  108|   291k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   291k|         using iterator_t = typename ParseInput::iterator_t;
  111|   291k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   291k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   291k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   291k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   291k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   291k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   291k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   291k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   291k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   291k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   291k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   291k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   291k|         }
  128|       |
  129|   291k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   291k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   291k|         }
  132|       |
  133|   291k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   291k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   291k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   291k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   291k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   291k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   291k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   291k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 290k, False: 1.56k]
  ------------------
  143|   290k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   290k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   290k|            }
  146|   290k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   290k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   290k|            }
  149|   290k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   290k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   290k|            }
  152|   290k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   290k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   290k|            }
  155|   290k|         }
  156|   291k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 290k, False: 1.56k]
  ------------------
  157|   290k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   290k|         }
  159|  1.56k|         else {
  160|  1.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.56k|         }
  162|   291k|         (void)m( result );
  163|   291k|         return result;
  164|   291k|      }
  165|   291k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   291k|      {
   73|   291k|#if defined( __cpp_exceptions )
   74|   291k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   291k|            try {
   76|   291k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   291k|            }
   78|   291k|            catch( ... ) {
   79|   291k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   291k|               throw;
   81|   291k|            }
   82|   291k|         }
   83|   291k|         else {
   84|   291k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   291k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   291k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   291k|      {
   44|   291k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   291k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   291k|   {
  104|   291k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   291k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   291k|      }
  107|   291k|      else {
  108|   291k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   291k|         using iterator_t = typename ParseInput::iterator_t;
  111|   291k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   291k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   291k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   291k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   291k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   291k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   291k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   291k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   291k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   291k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   291k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   291k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   291k|         }
  128|       |
  129|   291k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   291k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   291k|         }
  132|       |
  133|   291k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   291k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   291k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   291k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   291k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   291k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   291k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   291k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 290k, False: 1.56k]
  ------------------
  143|   290k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   290k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   290k|            }
  146|   290k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   290k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   290k|            }
  149|   290k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   290k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   290k|            }
  152|   290k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   290k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   290k|            }
  155|   290k|         }
  156|   291k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 290k, False: 1.56k]
  ------------------
  157|   290k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   290k|         }
  159|  1.56k|         else {
  160|  1.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.56k|         }
  162|   291k|         (void)m( result );
  163|   291k|         return result;
  164|   291k|      }
  165|   291k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   291k|      {
   73|   291k|#if defined( __cpp_exceptions )
   74|   291k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   291k|            try {
   76|   291k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   291k|            }
   78|   291k|            catch( ... ) {
   79|   291k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   291k|               throw;
   81|   291k|            }
   82|   291k|         }
   83|   291k|         else {
   84|   291k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   291k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   291k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   291k|      {
   59|   291k|         return Rule::match( in );
   60|   291k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|   290k|   {
  104|   290k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   290k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   290k|      }
  107|   290k|      else {
  108|   290k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   290k|         using iterator_t = typename ParseInput::iterator_t;
  111|   290k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   290k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   290k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   290k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   290k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   290k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   290k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   290k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   290k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   290k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   290k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   290k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   290k|         }
  128|       |
  129|   290k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   290k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   290k|         }
  132|       |
  133|   290k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   290k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   290k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   290k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   290k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   290k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   290k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   290k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 290k, False: 0]
  ------------------
  143|   290k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   290k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   290k|            }
  146|   290k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   290k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   290k|            }
  149|   290k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   290k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   290k|            }
  152|   290k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   290k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   290k|            }
  155|   290k|         }
  156|   290k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 290k, False: 0]
  ------------------
  157|   290k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   290k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   290k|         (void)m( result );
  163|   290k|         return result;
  164|   290k|      }
  165|   290k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEDaRT4_DpOT5_:
   72|   290k|      {
   73|   290k|#if defined( __cpp_exceptions )
   74|   290k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   290k|            try {
   76|   290k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   290k|            }
   78|   290k|            catch( ... ) {
   79|   290k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   290k|               throw;
   81|   290k|            }
   82|   290k|         }
   83|   290k|         else {
   84|   290k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   290k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   290k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   290k|      {
   44|   290k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   290k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  12.6M|   {
  104|  12.6M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  12.6M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  12.6M|      }
  107|  12.6M|      else {
  108|  12.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.6M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  12.6M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  12.6M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  12.6M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  12.6M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  12.6M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  12.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.6M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  12.6M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  12.6M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  12.6M|         }
  128|       |
  129|  12.6M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  12.6M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  12.6M|         }
  132|       |
  133|  12.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.6M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  12.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  12.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 12.3M, False: 290k]
  ------------------
  143|  12.3M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  12.3M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  12.3M|            }
  146|  12.3M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  12.3M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  12.3M|            }
  149|  12.3M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  12.3M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  12.3M|            }
  152|  12.3M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  12.3M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  12.3M|            }
  155|  12.3M|         }
  156|  12.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 12.3M, False: 290k]
  ------------------
  157|  12.3M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  12.3M|         }
  159|   290k|         else {
  160|   290k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   290k|         }
  162|  12.6M|         (void)m( result );
  163|  12.6M|         return result;
  164|  12.6M|      }
  165|  12.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  12.6M|      {
   73|  12.6M|#if defined( __cpp_exceptions )
   74|  12.6M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  12.6M|            try {
   76|  12.6M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  12.6M|            }
   78|  12.6M|            catch( ... ) {
   79|  12.6M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  12.6M|               throw;
   81|  12.6M|            }
   82|  12.6M|         }
   83|  12.6M|         else {
   84|  12.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.6M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  12.6M|      {
   59|  12.6M|         return Rule::match( in );
   60|  12.6M|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   290k|   {
  104|   290k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   290k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   290k|      }
  107|   290k|      else {
  108|   290k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   290k|         using iterator_t = typename ParseInput::iterator_t;
  111|   290k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   290k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   290k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   290k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   290k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   290k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   290k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   290k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   290k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   290k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   290k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   290k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   290k|         }
  128|       |
  129|   290k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   290k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   290k|         }
  132|       |
  133|   290k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   290k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   290k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   290k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   290k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   290k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   290k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   290k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 289k, False: 366]
  ------------------
  143|   289k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   289k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   289k|            }
  146|   289k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   289k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   289k|            }
  149|   289k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   289k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   289k|            }
  152|   289k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   289k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   289k|            }
  155|   289k|         }
  156|   290k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 289k, False: 366]
  ------------------
  157|   289k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   289k|         }
  159|    366|         else {
  160|    366|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    366|         }
  162|   290k|         (void)m( result );
  163|   290k|         return result;
  164|   290k|      }
  165|   290k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   290k|      {
   73|   290k|#if defined( __cpp_exceptions )
   74|   290k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   290k|            try {
   76|   290k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   290k|            }
   78|   290k|            catch( ... ) {
   79|   290k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   290k|               throw;
   81|   290k|            }
   82|   290k|         }
   83|   290k|         else {
   84|   290k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   290k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   290k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   290k|      {
   44|   290k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   290k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   290k|   {
  104|   290k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   290k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   290k|      }
  107|   290k|      else {
  108|   290k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   290k|         using iterator_t = typename ParseInput::iterator_t;
  111|   290k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   290k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   290k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   290k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   290k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   290k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   290k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   290k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   290k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   290k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   290k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   290k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   290k|         }
  128|       |
  129|   290k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   290k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   290k|         }
  132|       |
  133|   290k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   290k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   290k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   290k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   290k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   290k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   290k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   290k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.3k, False: 254k]
  ------------------
  143|  35.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  35.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  35.3k|            }
  146|  35.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  35.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  35.3k|            }
  149|  35.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  35.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  35.3k|            }
  152|  35.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  35.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.3k|            }
  155|  35.3k|         }
  156|   290k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.3k, False: 254k]
  ------------------
  157|  35.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.3k|         }
  159|   254k|         else {
  160|   254k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   254k|         }
  162|   290k|         (void)m( result );
  163|   290k|         return result;
  164|   290k|      }
  165|   290k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   290k|      {
   73|   290k|#if defined( __cpp_exceptions )
   74|   290k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   290k|            try {
   76|   290k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   290k|            }
   78|   290k|            catch( ... ) {
   79|   290k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   290k|               throw;
   81|   290k|            }
   82|   290k|         }
   83|   290k|         else {
   84|   290k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   290k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   290k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   290k|      {
   44|   290k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   290k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   290k|   {
  104|   290k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   290k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   290k|      }
  107|   290k|      else {
  108|   290k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   290k|         using iterator_t = typename ParseInput::iterator_t;
  111|   290k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   290k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   290k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   290k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   290k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   290k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   290k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   290k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   290k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   290k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   290k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   290k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   290k|         }
  128|       |
  129|   290k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   290k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   290k|         }
  132|       |
  133|   290k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   290k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   290k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   290k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   290k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   290k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   290k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   290k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.6k, False: 254k]
  ------------------
  143|  35.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  35.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  35.6k|            }
  146|  35.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  35.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  35.6k|            }
  149|  35.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  35.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  35.6k|            }
  152|  35.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  35.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.6k|            }
  155|  35.6k|         }
  156|   290k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.6k, False: 254k]
  ------------------
  157|  35.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.6k|         }
  159|   254k|         else {
  160|   254k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   254k|         }
  162|   290k|         (void)m( result );
  163|   290k|         return result;
  164|   290k|      }
  165|   290k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   290k|      {
   73|   290k|#if defined( __cpp_exceptions )
   74|   290k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   290k|            try {
   76|   290k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   290k|            }
   78|   290k|            catch( ... ) {
   79|   290k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   290k|               throw;
   81|   290k|            }
   82|   290k|         }
   83|   290k|         else {
   84|   290k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   290k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   290k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   290k|      {
   59|   290k|         return Rule::match( in );
   60|   290k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  35.6k|   {
  104|  35.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  35.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  35.6k|      }
  107|  35.6k|      else {
  108|  35.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  35.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  35.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  35.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  35.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  35.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  35.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  35.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  35.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  35.6k|         }
  128|       |
  129|  35.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  35.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  35.6k|         }
  132|       |
  133|  35.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  35.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  35.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.6k|         if( result ) {
  143|  35.6k|            if constexpr( has_apply_void ) {
  144|  35.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  35.6k|            }
  146|  35.6k|            else if constexpr( has_apply_bool ) {
  147|  35.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  35.6k|            }
  149|  35.6k|            else if constexpr( has_apply0_void ) {
  150|  35.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  35.6k|            }
  152|  35.6k|            else if constexpr( has_apply0_bool ) {
  153|  35.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.6k|            }
  155|  35.6k|         }
  156|  35.6k|         if( result ) {
  157|  35.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.6k|         }
  159|  35.6k|         else {
  160|  35.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.6k|         }
  162|  35.6k|         (void)m( result );
  163|  35.6k|         return result;
  164|  35.6k|      }
  165|  35.6k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.6k|      {
   44|  35.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.6k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  35.6k|   {
  104|  35.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  35.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  35.6k|      }
  107|  35.6k|      else {
  108|  35.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  35.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  35.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  35.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  35.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  35.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  35.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  35.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  35.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  35.6k|         }
  128|       |
  129|  35.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  35.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  35.6k|         }
  132|       |
  133|  35.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  35.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  35.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.3k, False: 366]
  ------------------
  143|  35.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  35.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  35.3k|            }
  146|  35.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  35.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  35.3k|            }
  149|  35.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  35.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  35.3k|            }
  152|  35.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  35.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.3k|            }
  155|  35.3k|         }
  156|  35.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.3k, False: 366]
  ------------------
  157|  35.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.3k|         }
  159|    366|         else {
  160|    366|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    366|         }
  162|  35.6k|         (void)m( result );
  163|  35.6k|         return result;
  164|  35.6k|      }
  165|  35.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  35.6k|      {
   73|  35.6k|#if defined( __cpp_exceptions )
   74|  35.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  35.6k|            try {
   76|  35.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  35.6k|            }
   78|  35.6k|            catch( ... ) {
   79|  35.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  35.6k|               throw;
   81|  35.6k|            }
   82|  35.6k|         }
   83|  35.6k|         else {
   84|  35.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.6k|      {
   44|  35.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  23.9M|   {
  104|  23.9M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.9M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.9M|      }
  107|  23.9M|      else {
  108|  23.9M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.9M|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.9M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  23.9M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  23.9M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  23.9M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  23.9M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  23.9M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  23.9M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.9M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.9M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.9M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.9M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  23.9M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.9M|         }
  128|       |
  129|  23.9M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  23.9M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.9M|         }
  132|       |
  133|  23.9M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.9M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.9M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.9M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  23.9M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.9M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.9M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.9M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.3k, False: 23.8M]
  ------------------
  143|  35.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  35.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  35.3k|            }
  146|  35.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  35.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  35.3k|            }
  149|  35.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  35.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  35.3k|            }
  152|  35.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  35.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.3k|            }
  155|  35.3k|         }
  156|  23.9M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.3k, False: 23.8M]
  ------------------
  157|  35.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.3k|         }
  159|  23.8M|         else {
  160|  23.8M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  23.8M|         }
  162|  23.9M|         (void)m( result );
  163|  23.9M|         return result;
  164|  23.9M|      }
  165|  23.9M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  23.9M|      {
   73|  23.9M|#if defined( __cpp_exceptions )
   74|  23.9M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  23.9M|            try {
   76|  23.9M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  23.9M|            }
   78|  23.9M|            catch( ... ) {
   79|  23.9M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  23.9M|               throw;
   81|  23.9M|            }
   82|  23.9M|         }
   83|  23.9M|         else {
   84|  23.9M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.9M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.9M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  23.9M|      {
   59|  23.9M|         return Rule::match( in );
   60|  23.9M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  23.8M|   {
  104|  23.8M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.8M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.8M|      }
  107|  23.8M|      else {
  108|  23.8M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.8M|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.8M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  23.8M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  23.8M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  23.8M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  23.8M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  23.8M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  23.8M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.8M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.8M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.8M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.8M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  23.8M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.8M|         }
  128|       |
  129|  23.8M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  23.8M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.8M|         }
  132|       |
  133|  23.8M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.8M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.8M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.8M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  23.8M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.8M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.8M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.8M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 23.8M, False: 366]
  ------------------
  143|  23.8M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  23.8M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  23.8M|            }
  146|  23.8M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  23.8M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  23.8M|            }
  149|  23.8M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  23.8M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  23.8M|            }
  152|  23.8M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  23.8M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.8M|            }
  155|  23.8M|         }
  156|  23.8M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 23.8M, False: 366]
  ------------------
  157|  23.8M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.8M|         }
  159|    366|         else {
  160|    366|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    366|         }
  162|  23.8M|         (void)m( result );
  163|  23.8M|         return result;
  164|  23.8M|      }
  165|  23.8M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  23.8M|      {
   73|  23.8M|#if defined( __cpp_exceptions )
   74|  23.8M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  23.8M|            try {
   76|  23.8M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  23.8M|            }
   78|  23.8M|            catch( ... ) {
   79|  23.8M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  23.8M|               throw;
   81|  23.8M|            }
   82|  23.8M|         }
   83|  23.8M|         else {
   84|  23.8M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.8M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.8M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  23.8M|      {
   44|  23.8M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  23.8M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  23.8M|   {
  104|  23.8M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.8M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.8M|      }
  107|  23.8M|      else {
  108|  23.8M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.8M|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.8M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  23.8M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  23.8M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  23.8M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  23.8M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  23.8M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  23.8M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.8M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.8M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.8M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.8M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  23.8M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.8M|         }
  128|       |
  129|  23.8M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  23.8M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.8M|         }
  132|       |
  133|  23.8M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.8M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.8M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.8M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  23.8M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.8M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.8M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.8M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 155k, False: 23.7M]
  ------------------
  143|   155k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   155k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   155k|            }
  146|   155k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   155k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   155k|            }
  149|   155k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   155k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   155k|            }
  152|   155k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   155k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   155k|            }
  155|   155k|         }
  156|  23.8M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 155k, False: 23.7M]
  ------------------
  157|   155k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   155k|         }
  159|  23.7M|         else {
  160|  23.7M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  23.7M|         }
  162|  23.8M|         (void)m( result );
  163|  23.8M|         return result;
  164|  23.8M|      }
  165|  23.8M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  23.8M|      {
   73|  23.8M|#if defined( __cpp_exceptions )
   74|  23.8M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  23.8M|            try {
   76|  23.8M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  23.8M|            }
   78|  23.8M|            catch( ... ) {
   79|  23.8M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  23.8M|               throw;
   81|  23.8M|            }
   82|  23.8M|         }
   83|  23.8M|         else {
   84|  23.8M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.8M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.8M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  23.8M|      {
   44|  23.8M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  23.8M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  23.8M|   {
  104|  23.8M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.8M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.8M|      }
  107|  23.8M|      else {
  108|  23.8M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.8M|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.8M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  23.8M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  23.8M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  23.8M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  23.8M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  23.8M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  23.8M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.8M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.8M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.8M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.8M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  23.8M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.8M|         }
  128|       |
  129|  23.8M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  23.8M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.8M|         }
  132|       |
  133|  23.8M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.8M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.8M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.8M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  23.8M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.8M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.8M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.8M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 155k, False: 23.7M]
  ------------------
  143|   155k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   155k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   155k|            }
  146|   155k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   155k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   155k|            }
  149|   155k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   155k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   155k|            }
  152|   155k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   155k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   155k|            }
  155|   155k|         }
  156|  23.8M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 155k, False: 23.7M]
  ------------------
  157|   155k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   155k|         }
  159|  23.7M|         else {
  160|  23.7M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  23.7M|         }
  162|  23.8M|         (void)m( result );
  163|  23.8M|         return result;
  164|  23.8M|      }
  165|  23.8M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  23.8M|      {
   73|  23.8M|#if defined( __cpp_exceptions )
   74|  23.8M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  23.8M|            try {
   76|  23.8M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  23.8M|            }
   78|  23.8M|            catch( ... ) {
   79|  23.8M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  23.8M|               throw;
   81|  23.8M|            }
   82|  23.8M|         }
   83|  23.8M|         else {
   84|  23.8M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.8M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.8M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  23.8M|      {
   59|  23.8M|         return Rule::match( in );
   60|  23.8M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   155k|   {
  104|   155k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   155k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   155k|      }
  107|   155k|      else {
  108|   155k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   155k|         using iterator_t = typename ParseInput::iterator_t;
  111|   155k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   155k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   155k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   155k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   155k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   155k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   155k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   155k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   155k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   155k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   155k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   155k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   155k|         }
  128|       |
  129|   155k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   155k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   155k|         }
  132|       |
  133|   155k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   155k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   155k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   155k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   155k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   155k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   155k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   155k|         if( result ) {
  143|   155k|            if constexpr( has_apply_void ) {
  144|   155k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   155k|            }
  146|   155k|            else if constexpr( has_apply_bool ) {
  147|   155k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   155k|            }
  149|   155k|            else if constexpr( has_apply0_void ) {
  150|   155k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   155k|            }
  152|   155k|            else if constexpr( has_apply0_bool ) {
  153|   155k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   155k|            }
  155|   155k|         }
  156|   155k|         if( result ) {
  157|   155k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   155k|         }
  159|   155k|         else {
  160|   155k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   155k|         }
  162|   155k|         (void)m( result );
  163|   155k|         return result;
  164|   155k|      }
  165|   155k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   155k|      {
   44|   155k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   155k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   155k|   {
  104|   155k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   155k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   155k|      }
  107|   155k|      else {
  108|   155k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   155k|         using iterator_t = typename ParseInput::iterator_t;
  111|   155k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   155k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   155k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   155k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   155k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   155k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   155k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   155k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   155k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   155k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   155k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   155k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   155k|         }
  128|       |
  129|   155k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   155k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   155k|         }
  132|       |
  133|   155k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   155k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   155k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   155k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   155k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   155k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   155k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   155k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 155k, False: 94]
  ------------------
  143|   155k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   155k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   155k|            }
  146|   155k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   155k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   155k|            }
  149|   155k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   155k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   155k|            }
  152|   155k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   155k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   155k|            }
  155|   155k|         }
  156|   155k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 155k, False: 94]
  ------------------
  157|   155k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   155k|         }
  159|     94|         else {
  160|     94|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     94|         }
  162|   155k|         (void)m( result );
  163|   155k|         return result;
  164|   155k|      }
  165|   155k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   155k|      {
   73|   155k|#if defined( __cpp_exceptions )
   74|   155k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   155k|            try {
   76|   155k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   155k|            }
   78|   155k|            catch( ... ) {
   79|   155k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   155k|               throw;
   81|   155k|            }
   82|   155k|         }
   83|   155k|         else {
   84|   155k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   155k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   155k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   155k|      {
   44|   155k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   155k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   155k|   {
  104|   155k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   155k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   155k|      }
  107|   155k|      else {
  108|   155k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   155k|         using iterator_t = typename ParseInput::iterator_t;
  111|   155k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   155k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   155k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   155k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   155k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   155k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   155k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   155k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   155k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   155k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   155k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   155k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   155k|         }
  128|       |
  129|   155k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   155k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   155k|         }
  132|       |
  133|   155k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   155k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   155k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   155k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   155k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   155k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   155k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   155k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.6k, False: 124k]
  ------------------
  143|  30.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.6k|            }
  146|  30.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.6k|            }
  149|  30.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.6k|            }
  152|  30.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.6k|            }
  155|  30.6k|         }
  156|   155k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.6k, False: 124k]
  ------------------
  157|  30.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.6k|         }
  159|   124k|         else {
  160|   124k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   124k|         }
  162|   155k|         (void)m( result );
  163|   155k|         return result;
  164|   155k|      }
  165|   155k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   155k|      {
   73|   155k|#if defined( __cpp_exceptions )
   74|   155k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   155k|            try {
   76|   155k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   155k|            }
   78|   155k|            catch( ... ) {
   79|   155k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   155k|               throw;
   81|   155k|            }
   82|   155k|         }
   83|   155k|         else {
   84|   155k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   155k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   155k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   155k|      {
   44|   155k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   155k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   155k|   {
  104|   155k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   155k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   155k|      }
  107|   155k|      else {
  108|   155k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   155k|         using iterator_t = typename ParseInput::iterator_t;
  111|   155k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   155k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   155k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   155k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   155k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   155k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   155k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   155k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   155k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   155k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   155k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   155k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   155k|         }
  128|       |
  129|   155k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   155k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   155k|         }
  132|       |
  133|   155k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   155k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   155k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   155k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   155k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   155k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   155k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   155k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.6k, False: 124k]
  ------------------
  143|  30.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.6k|            }
  146|  30.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.6k|            }
  149|  30.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.6k|            }
  152|  30.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.6k|            }
  155|  30.6k|         }
  156|   155k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.6k, False: 124k]
  ------------------
  157|  30.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.6k|         }
  159|   124k|         else {
  160|   124k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   124k|         }
  162|   155k|         (void)m( result );
  163|   155k|         return result;
  164|   155k|      }
  165|   155k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   155k|      {
   73|   155k|#if defined( __cpp_exceptions )
   74|   155k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   155k|            try {
   76|   155k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   155k|            }
   78|   155k|            catch( ... ) {
   79|   155k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   155k|               throw;
   81|   155k|            }
   82|   155k|         }
   83|   155k|         else {
   84|   155k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   155k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   155k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   155k|      {
   59|   155k|         return Rule::match( in );
   60|   155k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  30.6k|   {
  104|  30.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.6k|      }
  107|  30.6k|      else {
  108|  30.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  30.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  30.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  30.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  30.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  30.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  30.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  30.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.6k|         }
  128|       |
  129|  30.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  30.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.6k|         }
  132|       |
  133|  30.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  30.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.6k|         if( result ) {
  143|  30.6k|            if constexpr( has_apply_void ) {
  144|  30.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.6k|            }
  146|  30.6k|            else if constexpr( has_apply_bool ) {
  147|  30.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.6k|            }
  149|  30.6k|            else if constexpr( has_apply0_void ) {
  150|  30.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.6k|            }
  152|  30.6k|            else if constexpr( has_apply0_bool ) {
  153|  30.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.6k|            }
  155|  30.6k|         }
  156|  30.6k|         if( result ) {
  157|  30.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.6k|         }
  159|  30.6k|         else {
  160|  30.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.6k|         }
  162|  30.6k|         (void)m( result );
  163|  30.6k|         return result;
  164|  30.6k|      }
  165|  30.6k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.6k|      {
   44|  30.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.6k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  30.6k|   {
  104|  30.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.6k|      }
  107|  30.6k|      else {
  108|  30.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  30.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  30.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  30.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  30.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  30.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  30.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  30.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.6k|         }
  128|       |
  129|  30.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  30.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.6k|         }
  132|       |
  133|  30.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  30.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.6k, False: 42]
  ------------------
  143|  30.6k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.6k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.6k|            }
  146|  30.6k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.6k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.6k|            }
  149|  30.6k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.6k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.6k|            }
  152|  30.6k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.6k|            }
  155|  30.6k|         }
  156|  30.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.6k, False: 42]
  ------------------
  157|  30.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.6k|         }
  159|     42|         else {
  160|     42|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     42|         }
  162|  30.6k|         (void)m( result );
  163|  30.6k|         return result;
  164|  30.6k|      }
  165|  30.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  30.6k|      {
   73|  30.6k|#if defined( __cpp_exceptions )
   74|  30.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  30.6k|            try {
   76|  30.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  30.6k|            }
   78|  30.6k|            catch( ... ) {
   79|  30.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  30.6k|               throw;
   81|  30.6k|            }
   82|  30.6k|         }
   83|  30.6k|         else {
   84|  30.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.6k|      {
   44|  30.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  61.3k|   {
  104|  61.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  61.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  61.3k|      }
  107|  61.3k|      else {
  108|  61.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  61.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  61.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  61.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  61.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  61.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  61.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  61.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  61.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  61.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  61.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  61.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  61.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  61.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  61.3k|         }
  128|       |
  129|  61.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  61.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  61.3k|         }
  132|       |
  133|  61.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  61.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  61.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  61.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  61.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  61.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  61.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  61.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 61.3k, False: 42]
  ------------------
  143|  61.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  61.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  61.3k|            }
  146|  61.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  61.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  61.3k|            }
  149|  61.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  61.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  61.3k|            }
  152|  61.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  61.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  61.3k|            }
  155|  61.3k|         }
  156|  61.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 61.3k, False: 42]
  ------------------
  157|  61.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  61.3k|         }
  159|     42|         else {
  160|     42|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     42|         }
  162|  61.3k|         (void)m( result );
  163|  61.3k|         return result;
  164|  61.3k|      }
  165|  61.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  61.3k|      {
   73|  61.3k|#if defined( __cpp_exceptions )
   74|  61.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  61.3k|            try {
   76|  61.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  61.3k|            }
   78|  61.3k|            catch( ... ) {
   79|  61.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  61.3k|               throw;
   81|  61.3k|            }
   82|  61.3k|         }
   83|  61.3k|         else {
   84|  61.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  61.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  61.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  61.3k|      {
   59|  61.3k|         return Rule::match( in );
   60|  61.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   124k|   {
  104|   124k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   124k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   124k|      }
  107|   124k|      else {
  108|   124k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   124k|         using iterator_t = typename ParseInput::iterator_t;
  111|   124k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   124k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   124k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   124k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   124k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   124k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   124k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   124k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   124k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   124k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   124k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   124k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   124k|         }
  128|       |
  129|   124k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   124k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   124k|         }
  132|       |
  133|   124k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   124k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   124k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   124k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   124k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   124k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   124k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   124k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.0k, False: 79.9k]
  ------------------
  143|  45.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  45.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  45.0k|            }
  146|  45.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  45.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  45.0k|            }
  149|  45.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  45.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  45.0k|            }
  152|  45.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  45.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.0k|            }
  155|  45.0k|         }
  156|   124k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.0k, False: 79.9k]
  ------------------
  157|  45.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.0k|         }
  159|  79.9k|         else {
  160|  79.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  79.9k|         }
  162|   124k|         (void)m( result );
  163|   124k|         return result;
  164|   124k|      }
  165|   124k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   124k|      {
   73|   124k|#if defined( __cpp_exceptions )
   74|   124k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   124k|            try {
   76|   124k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   124k|            }
   78|   124k|            catch( ... ) {
   79|   124k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   124k|               throw;
   81|   124k|            }
   82|   124k|         }
   83|   124k|         else {
   84|   124k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   124k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   124k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   124k|      {
   44|   124k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   124k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   177k|   {
  104|   177k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   177k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   177k|      }
  107|   177k|      else {
  108|   177k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   177k|         using iterator_t = typename ParseInput::iterator_t;
  111|   177k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   177k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   177k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   177k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   177k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   177k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   177k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   177k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   177k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   177k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   177k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   177k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   177k|         }
  128|       |
  129|   177k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   177k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   177k|         }
  132|       |
  133|   177k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   177k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   177k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   177k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   177k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   177k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   177k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   177k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 56.7k, False: 120k]
  ------------------
  143|  56.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  56.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  56.7k|            }
  146|  56.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  56.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  56.7k|            }
  149|  56.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  56.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  56.7k|            }
  152|  56.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  56.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  56.7k|            }
  155|  56.7k|         }
  156|   177k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 56.7k, False: 120k]
  ------------------
  157|  56.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  56.7k|         }
  159|   120k|         else {
  160|   120k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   120k|         }
  162|   177k|         (void)m( result );
  163|   177k|         return result;
  164|   177k|      }
  165|   177k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   177k|      {
   73|   177k|#if defined( __cpp_exceptions )
   74|   177k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   177k|            try {
   76|   177k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   177k|            }
   78|   177k|            catch( ... ) {
   79|   177k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   177k|               throw;
   81|   177k|            }
   82|   177k|         }
   83|   177k|         else {
   84|   177k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   177k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   177k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   177k|      {
   59|   177k|         return Rule::match( in );
   60|   177k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  45.0k|   {
  104|  45.0k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  45.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  45.0k|      }
  107|  45.0k|      else {
  108|  45.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  45.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  45.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  45.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  45.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  45.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  45.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  45.0k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  45.0k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  45.0k|         }
  128|       |
  129|  45.0k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  45.0k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  45.0k|         }
  132|       |
  133|  45.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  45.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  45.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0k|         if( result ) {
  143|  45.0k|            if constexpr( has_apply_void ) {
  144|  45.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  45.0k|            }
  146|  45.0k|            else if constexpr( has_apply_bool ) {
  147|  45.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  45.0k|            }
  149|  45.0k|            else if constexpr( has_apply0_void ) {
  150|  45.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  45.0k|            }
  152|  45.0k|            else if constexpr( has_apply0_bool ) {
  153|  45.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.0k|            }
  155|  45.0k|         }
  156|  45.0k|         if( result ) {
  157|  45.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.0k|         }
  159|  45.0k|         else {
  160|  45.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  45.0k|         }
  162|  45.0k|         (void)m( result );
  163|  45.0k|         return result;
  164|  45.0k|      }
  165|  45.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  45.0k|      {
   44|  45.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.0k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  45.0k|   {
  104|  45.0k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  45.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  45.0k|      }
  107|  45.0k|      else {
  108|  45.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  45.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  45.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  45.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  45.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  45.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  45.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  45.0k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  45.0k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  45.0k|         }
  128|       |
  129|  45.0k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  45.0k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  45.0k|         }
  132|       |
  133|  45.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  45.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  45.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.0k, False: 0]
  ------------------
  143|  45.0k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  45.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  45.0k|            }
  146|  45.0k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  45.0k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  45.0k|            }
  149|  45.0k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  45.0k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  45.0k|            }
  152|  45.0k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  45.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.0k|            }
  155|  45.0k|         }
  156|  45.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.0k, False: 0]
  ------------------
  157|  45.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  45.0k|         (void)m( result );
  163|  45.0k|         return result;
  164|  45.0k|      }
  165|  45.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  45.0k|      {
   73|  45.0k|#if defined( __cpp_exceptions )
   74|  45.0k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  45.0k|            try {
   76|  45.0k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  45.0k|            }
   78|  45.0k|            catch( ... ) {
   79|  45.0k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  45.0k|               throw;
   81|  45.0k|            }
   82|  45.0k|         }
   83|  45.0k|         else {
   84|  45.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  45.0k|      {
   44|  45.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  79.9k|   {
  104|  79.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  79.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  79.9k|      }
  107|  79.9k|      else {
  108|  79.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  79.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  79.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  79.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  79.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  79.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  79.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  79.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  79.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  79.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  79.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  79.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  79.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  79.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  79.9k|         }
  128|       |
  129|  79.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  79.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  79.9k|         }
  132|       |
  133|  79.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  79.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  79.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  79.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  79.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  79.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  79.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  79.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 79.5k, False: 389]
  ------------------
  143|  79.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  79.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  79.5k|            }
  146|  79.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  79.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  79.5k|            }
  149|  79.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  79.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  79.5k|            }
  152|  79.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  79.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  79.5k|            }
  155|  79.5k|         }
  156|  79.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 79.5k, False: 389]
  ------------------
  157|  79.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  79.5k|         }
  159|    389|         else {
  160|    389|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    389|         }
  162|  79.9k|         (void)m( result );
  163|  79.9k|         return result;
  164|  79.9k|      }
  165|  79.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  79.9k|      {
   73|  79.9k|#if defined( __cpp_exceptions )
   74|  79.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  79.9k|            try {
   76|  79.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  79.9k|            }
   78|  79.9k|            catch( ... ) {
   79|  79.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  79.9k|               throw;
   81|  79.9k|            }
   82|  79.9k|         }
   83|  79.9k|         else {
   84|  79.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  79.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  79.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  79.9k|      {
   59|  79.9k|         return Rule::match( in );
   60|  79.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    389|   {
  104|    389|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|    389|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|    389|      }
  107|    389|      else {
  108|    389|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    389|         using iterator_t = typename ParseInput::iterator_t;
  111|    389|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|    389|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|    389|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|    389|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|    389|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|    389|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|    389|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    389|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    389|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    389|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|    389|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|    389|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|    389|         }
  128|       |
  129|    389|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|    389|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|    389|         }
  132|       |
  133|    389|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    389|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    389|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    389|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|    389|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    389|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    389|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    389|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 337, False: 52]
  ------------------
  143|    337|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    337|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    337|            }
  146|    337|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    337|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    337|            }
  149|    337|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    337|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    337|            }
  152|    337|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    337|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    337|            }
  155|    337|         }
  156|    389|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 337, False: 52]
  ------------------
  157|    337|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    337|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|    389|         (void)m( result );
  163|    389|         return result;
  164|    389|      }
  165|    389|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    389|      {
   73|    389|#if defined( __cpp_exceptions )
   74|    389|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|    389|            try {
   76|    389|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|    389|            }
   78|    389|            catch( ... ) {
   79|    389|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|    389|               throw;
   81|    389|            }
   82|    389|         }
   83|    389|         else {
   84|    389|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    389|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    389|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    389|      {
   59|    389|         return Rule::match( in );
   60|    389|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  23.7M|   {
  104|  23.7M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  23.7M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  23.7M|      }
  107|  23.7M|      else {
  108|  23.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  23.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  23.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  23.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  23.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  23.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  23.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  23.7M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  23.7M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  23.7M|         }
  128|       |
  129|  23.7M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  23.7M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  23.7M|         }
  132|       |
  133|  23.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.7M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  23.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  23.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 23.7M, False: 272]
  ------------------
  143|  23.7M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  23.7M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  23.7M|            }
  146|  23.7M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  23.7M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  23.7M|            }
  149|  23.7M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  23.7M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  23.7M|            }
  152|  23.7M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  23.7M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.7M|            }
  155|  23.7M|         }
  156|  23.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 23.7M, False: 272]
  ------------------
  157|  23.7M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.7M|         }
  159|    272|         else {
  160|    272|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    272|         }
  162|  23.7M|         (void)m( result );
  163|  23.7M|         return result;
  164|  23.7M|      }
  165|  23.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  23.7M|      {
   73|  23.7M|#if defined( __cpp_exceptions )
   74|  23.7M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  23.7M|            try {
   76|  23.7M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  23.7M|            }
   78|  23.7M|            catch( ... ) {
   79|  23.7M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  23.7M|               throw;
   81|  23.7M|            }
   82|  23.7M|         }
   83|  23.7M|         else {
   84|  23.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  23.7M|      {
   59|  23.7M|         return Rule::match( in );
   60|  23.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.9k|   {
  104|  11.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  11.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  11.9k|      }
  107|  11.9k|      else {
  108|  11.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  11.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  11.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  11.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  11.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  11.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  11.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  11.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  11.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  11.9k|         }
  128|       |
  129|  11.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  11.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  11.9k|         }
  132|       |
  133|  11.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  11.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.67k, False: 8.29k]
  ------------------
  143|  3.67k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.67k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.67k|            }
  146|  3.67k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.67k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.67k|            }
  149|  3.67k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.67k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.67k|            }
  152|  3.67k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.67k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.67k|            }
  155|  3.67k|         }
  156|  11.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.67k, False: 8.29k]
  ------------------
  157|  3.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.67k|         }
  159|  8.29k|         else {
  160|  8.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.29k|         }
  162|  11.9k|         (void)m( result );
  163|  11.9k|         return result;
  164|  11.9k|      }
  165|  11.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.9k|      {
   73|  11.9k|#if defined( __cpp_exceptions )
   74|  11.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  11.9k|            try {
   76|  11.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  11.9k|            }
   78|  11.9k|            catch( ... ) {
   79|  11.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  11.9k|               throw;
   81|  11.9k|            }
   82|  11.9k|         }
   83|  11.9k|         else {
   84|  11.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.9k|      {
   44|  11.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.9k|   {
  104|  11.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  11.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  11.9k|      }
  107|  11.9k|      else {
  108|  11.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  11.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  11.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  11.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  11.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  11.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  11.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  11.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  11.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  11.9k|         }
  128|       |
  129|  11.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  11.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  11.9k|         }
  132|       |
  133|  11.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  11.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.67k, False: 8.29k]
  ------------------
  143|  3.67k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.67k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.67k|            }
  146|  3.67k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.67k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.67k|            }
  149|  3.67k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.67k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.67k|            }
  152|  3.67k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.67k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.67k|            }
  155|  3.67k|         }
  156|  11.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.67k, False: 8.29k]
  ------------------
  157|  3.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.67k|         }
  159|  8.29k|         else {
  160|  8.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.29k|         }
  162|  11.9k|         (void)m( result );
  163|  11.9k|         return result;
  164|  11.9k|      }
  165|  11.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_9str_labelENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.9k|      {
   73|  11.9k|#if defined( __cpp_exceptions )
   74|  11.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  11.9k|            try {
   76|  11.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  11.9k|            }
   78|  11.9k|            catch( ... ) {
   79|  11.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  11.9k|               throw;
   81|  11.9k|            }
   82|  11.9k|         }
   83|  11.9k|         else {
   84|  11.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_9str_labelENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.9k|      {
   44|  11.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.9k|   {
  104|  11.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  11.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  11.9k|      }
  107|  11.9k|      else {
  108|  11.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  11.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  11.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  11.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  11.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  11.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  11.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  11.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  11.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  11.9k|         }
  128|       |
  129|  11.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  11.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  11.9k|         }
  132|       |
  133|  11.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  11.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.36k, False: 7.60k]
  ------------------
  143|  4.36k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.36k|            }
  146|  4.36k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.36k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.36k|            }
  149|  4.36k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.36k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.36k|            }
  152|  4.36k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.36k|            }
  155|  4.36k|         }
  156|  11.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.36k, False: 7.60k]
  ------------------
  157|  4.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.36k|         }
  159|  7.60k|         else {
  160|  7.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.60k|         }
  162|  11.9k|         (void)m( result );
  163|  11.9k|         return result;
  164|  11.9k|      }
  165|  11.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.9k|      {
   73|  11.9k|#if defined( __cpp_exceptions )
   74|  11.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  11.9k|            try {
   76|  11.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  11.9k|            }
   78|  11.9k|            catch( ... ) {
   79|  11.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  11.9k|               throw;
   81|  11.9k|            }
   82|  11.9k|         }
   83|  11.9k|         else {
   84|  11.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  11.9k|      {
   59|  11.9k|         return Rule::match( in );
   60|  11.9k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  10.5k|   {
  104|  10.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  10.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  10.5k|      }
  107|  10.5k|      else {
  108|  10.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  10.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  10.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  10.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  10.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  10.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  10.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  10.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  10.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  10.5k|         }
  128|       |
  129|  10.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  10.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  10.5k|         }
  132|       |
  133|  10.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  10.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.99k, False: 1.60k]
  ------------------
  143|  8.99k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  8.99k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  8.99k|            }
  146|  8.99k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  8.99k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  8.99k|            }
  149|  8.99k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  8.99k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  8.99k|            }
  152|  8.99k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  8.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.99k|            }
  155|  8.99k|         }
  156|  10.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.99k, False: 1.60k]
  ------------------
  157|  8.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.99k|         }
  159|  1.60k|         else {
  160|  1.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60k|         }
  162|  10.5k|         (void)m( result );
  163|  10.5k|         return result;
  164|  10.5k|      }
  165|  10.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  10.5k|      {
   73|  10.5k|#if defined( __cpp_exceptions )
   74|  10.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  10.5k|            try {
   76|  10.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  10.5k|            }
   78|  10.5k|            catch( ... ) {
   79|  10.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  10.5k|               throw;
   81|  10.5k|            }
   82|  10.5k|         }
   83|  10.5k|         else {
   84|  10.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.5k|      {
   44|  10.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  10.5k|   {
  104|  10.5k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  10.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  10.5k|      }
  107|  10.5k|      else {
  108|  10.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  10.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  10.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  10.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  10.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  10.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  10.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  10.5k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  10.5k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  10.5k|         }
  128|       |
  129|  10.5k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  10.5k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  10.5k|         }
  132|       |
  133|  10.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  10.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.99k, False: 1.60k]
  ------------------
  143|  8.99k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  8.99k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  8.99k|            }
  146|  8.99k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  8.99k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  8.99k|            }
  149|  8.99k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  8.99k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  8.99k|            }
  152|  8.99k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  8.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.99k|            }
  155|  8.99k|         }
  156|  10.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.99k, False: 1.60k]
  ------------------
  157|  8.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.99k|         }
  159|  1.60k|         else {
  160|  1.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60k|         }
  162|  10.5k|         (void)m( result );
  163|  10.5k|         return result;
  164|  10.5k|      }
  165|  10.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  10.5k|      {
   73|  10.5k|#if defined( __cpp_exceptions )
   74|  10.5k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  10.5k|            try {
   76|  10.5k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  10.5k|            }
   78|  10.5k|            catch( ... ) {
   79|  10.5k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  10.5k|               throw;
   81|  10.5k|            }
   82|  10.5k|         }
   83|  10.5k|         else {
   84|  10.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.5k|      {
   59|  10.5k|         return Rule::match( in );
   60|  10.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  25.3k|   {
  104|  25.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  25.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  25.3k|      }
  107|  25.3k|      else {
  108|  25.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  25.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  25.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  25.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  25.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  25.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  25.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  25.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  25.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  25.3k|         }
  128|       |
  129|  25.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  25.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  25.3k|         }
  132|       |
  133|  25.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  25.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  25.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11.7k, False: 13.5k]
  ------------------
  143|  11.7k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  11.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  11.7k|            }
  146|  11.7k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  11.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  11.7k|            }
  149|  11.7k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  11.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  11.7k|            }
  152|  11.7k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  11.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  11.7k|            }
  155|  11.7k|         }
  156|  25.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11.7k, False: 13.5k]
  ------------------
  157|  11.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  11.7k|         }
  159|  13.5k|         else {
  160|  13.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.5k|         }
  162|  25.3k|         (void)m( result );
  163|  25.3k|         return result;
  164|  25.3k|      }
  165|  25.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  25.3k|      {
   73|  25.3k|#if defined( __cpp_exceptions )
   74|  25.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  25.3k|            try {
   76|  25.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  25.3k|            }
   78|  25.3k|            catch( ... ) {
   79|  25.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  25.3k|               throw;
   81|  25.3k|            }
   82|  25.3k|         }
   83|  25.3k|         else {
   84|  25.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  25.3k|      {
   59|  25.3k|         return Rule::match( in );
   60|  25.3k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.67k, False: 666]
  ------------------
  143|  3.67k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  3.67k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  3.67k|            }
  146|  3.67k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  3.67k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  3.67k|            }
  149|  3.67k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  3.67k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  3.67k|            }
  152|  3.67k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  3.67k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.67k|            }
  155|  3.67k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.67k, False: 666]
  ------------------
  157|  3.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.67k|         }
  159|    666|         else {
  160|    666|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    666|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|  4.34k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.34k|            try {
   76|  4.34k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.34k|            }
   78|  4.34k|            catch( ... ) {
   79|  4.34k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.34k|               throw;
   81|  4.34k|            }
   82|  4.34k|         }
   83|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.13k, False: 2.21k]
  ------------------
  143|  2.13k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.13k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.13k|            }
  146|  2.13k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.13k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.13k|            }
  149|  2.13k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.13k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.13k|            }
  152|  2.13k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.13k|            }
  155|  2.13k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.13k, False: 2.21k]
  ------------------
  157|  2.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.13k|         }
  159|  2.21k|         else {
  160|  2.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.21k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|  4.34k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.34k|            try {
   76|  4.34k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.34k|            }
   78|  4.34k|            catch( ... ) {
   79|  4.34k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.34k|               throw;
   81|  4.34k|            }
   82|  4.34k|         }
   83|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.34k, False: 0]
  ------------------
  143|  4.34k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.34k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.34k|            }
  146|  4.34k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.34k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.34k|            }
  149|  4.34k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.34k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.34k|            }
  152|  4.34k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.34k|            }
  155|  4.34k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.34k, False: 0]
  ------------------
  157|  4.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.34k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|  4.34k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.34k|            try {
   76|  4.34k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.34k|            }
   78|  4.34k|            catch( ... ) {
   79|  4.34k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.34k|               throw;
   81|  4.34k|            }
   82|  4.34k|         }
   83|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  143|  4.34k|            if constexpr( has_apply_void ) {
  144|  4.34k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.34k|            }
  146|  4.34k|            else if constexpr( has_apply_bool ) {
  147|  4.34k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.34k|            }
  149|  4.34k|            else if constexpr( has_apply0_void ) {
  150|  4.34k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.34k|            }
  152|  4.34k|            else if constexpr( has_apply0_bool ) {
  153|  4.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.34k|            }
  155|  4.34k|         }
  156|  4.34k|         if( result ) {
  157|  4.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.34k|         }
  159|  4.34k|         else {
  160|  4.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.34k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.63k, False: 2.71k]
  ------------------
  143|  1.63k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.63k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.63k|            }
  146|  1.63k|            else if constexpr( has_apply_bool ) {
  147|  1.63k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.63k|            }
  149|  1.63k|            else if constexpr( has_apply0_void ) {
  150|  1.63k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.63k|            }
  152|  1.63k|            else if constexpr( has_apply0_bool ) {
  153|  1.63k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.63k|            }
  155|  1.63k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.63k, False: 2.71k]
  ------------------
  157|  1.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.63k|         }
  159|  2.71k|         else {
  160|  2.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.71k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|  4.34k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.34k|            try {
   76|  4.34k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.34k|            }
   78|  4.34k|            catch( ... ) {
   79|  4.34k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.34k|               throw;
   81|  4.34k|            }
   82|  4.34k|         }
   83|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 211, False: 4.13k]
  ------------------
  143|    211|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    211|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    211|            }
  146|    211|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    211|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    211|            }
  149|    211|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    211|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    211|            }
  152|    211|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    211|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    211|            }
  155|    211|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 211, False: 4.13k]
  ------------------
  157|    211|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    211|         }
  159|  4.13k|         else {
  160|  4.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.13k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|  4.34k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.34k|            try {
   76|  4.34k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.34k|            }
   78|  4.34k|            catch( ... ) {
   79|  4.34k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.34k|               throw;
   81|  4.34k|            }
   82|  4.34k|         }
   83|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.34k|      {
   59|  4.34k|         return Rule::match( in );
   60|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.13k|   {
  104|  4.13k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.13k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.13k|      }
  107|  4.13k|      else {
  108|  4.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.13k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.13k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.13k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.13k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.13k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.13k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.13k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.13k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.13k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.13k|         }
  128|       |
  129|  4.13k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.13k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.13k|         }
  132|       |
  133|  4.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.13k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 249, False: 3.88k]
  ------------------
  143|    249|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    249|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    249|            }
  146|    249|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    249|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    249|            }
  149|    249|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    249|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    249|            }
  152|    249|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    249|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    249|            }
  155|    249|         }
  156|  4.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 249, False: 3.88k]
  ------------------
  157|    249|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    249|         }
  159|  3.88k|         else {
  160|  3.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.88k|         }
  162|  4.13k|         (void)m( result );
  163|  4.13k|         return result;
  164|  4.13k|      }
  165|  4.13k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.13k|      {
   73|  4.13k|#if defined( __cpp_exceptions )
   74|  4.13k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.13k|            try {
   76|  4.13k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.13k|            }
   78|  4.13k|            catch( ... ) {
   79|  4.13k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.13k|               throw;
   81|  4.13k|            }
   82|  4.13k|         }
   83|  4.13k|         else {
   84|  4.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.13k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.13k|      {
   59|  4.13k|         return Rule::match( in );
   60|  4.13k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.88k|   {
  104|  3.88k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.88k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.88k|      }
  107|  3.88k|      else {
  108|  3.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.88k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.88k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.88k|         }
  128|       |
  129|  3.88k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.88k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.88k|         }
  132|       |
  133|  3.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 226, False: 3.65k]
  ------------------
  143|    226|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    226|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    226|            }
  146|    226|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    226|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    226|            }
  149|    226|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    226|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    226|            }
  152|    226|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    226|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    226|            }
  155|    226|         }
  156|  3.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 226, False: 3.65k]
  ------------------
  157|    226|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    226|         }
  159|  3.65k|         else {
  160|  3.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.65k|         }
  162|  3.88k|         (void)m( result );
  163|  3.88k|         return result;
  164|  3.88k|      }
  165|  3.88k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.88k|      {
   73|  3.88k|#if defined( __cpp_exceptions )
   74|  3.88k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.88k|            try {
   76|  3.88k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.88k|            }
   78|  3.88k|            catch( ... ) {
   79|  3.88k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.88k|               throw;
   81|  3.88k|            }
   82|  3.88k|         }
   83|  3.88k|         else {
   84|  3.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.88k|      {
   59|  3.88k|         return Rule::match( in );
   60|  3.88k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|  3.65k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.65k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.65k|      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.65k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.65k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.65k|         }
  128|       |
  129|  3.65k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.65k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.65k|         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 272, False: 3.38k]
  ------------------
  143|    272|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    272|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    272|            }
  146|    272|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    272|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    272|            }
  149|    272|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    272|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    272|            }
  152|    272|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    272|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    272|            }
  155|    272|         }
  156|  3.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 272, False: 3.38k]
  ------------------
  157|    272|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    272|         }
  159|  3.38k|         else {
  160|  3.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.38k|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|  3.65k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.65k|            try {
   76|  3.65k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.65k|            }
   78|  3.65k|            catch( ... ) {
   79|  3.65k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.65k|               throw;
   81|  3.65k|            }
   82|  3.65k|         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.65k|      {
   59|  3.65k|         return Rule::match( in );
   60|  3.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|  3.38k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  3.38k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  3.38k|      }
  107|  3.38k|      else {
  108|  3.38k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.38k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.38k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  3.38k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  3.38k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.38k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.38k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.38k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  3.38k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  3.38k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  3.38k|         }
  128|       |
  129|  3.38k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  3.38k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  3.38k|         }
  132|       |
  133|  3.38k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.38k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.38k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.38k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  3.38k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.38k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.38k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.38k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 444, False: 2.94k]
  ------------------
  143|    444|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    444|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    444|            }
  146|    444|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    444|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    444|            }
  149|    444|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    444|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    444|            }
  152|    444|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    444|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    444|            }
  155|    444|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 444, False: 2.94k]
  ------------------
  157|    444|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    444|         }
  159|  2.94k|         else {
  160|  2.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.94k|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.38k|      {
   73|  3.38k|#if defined( __cpp_exceptions )
   74|  3.38k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  3.38k|            try {
   76|  3.38k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  3.38k|            }
   78|  3.38k|            catch( ... ) {
   79|  3.38k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  3.38k|               throw;
   81|  3.38k|            }
   82|  3.38k|         }
   83|  3.38k|         else {
   84|  3.38k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.38k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.38k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.38k|      {
   59|  3.38k|         return Rule::match( in );
   60|  3.38k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.94k|   {
  104|  2.94k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.94k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.94k|      }
  107|  2.94k|      else {
  108|  2.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.94k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.94k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.94k|         }
  128|       |
  129|  2.94k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.94k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.94k|         }
  132|       |
  133|  2.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 230, False: 2.71k]
  ------------------
  143|    230|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|    230|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|    230|            }
  146|    230|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|    230|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|    230|            }
  149|    230|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|    230|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|    230|            }
  152|    230|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|    230|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    230|            }
  155|    230|         }
  156|  2.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 230, False: 2.71k]
  ------------------
  157|    230|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    230|         }
  159|  2.71k|         else {
  160|  2.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.71k|         }
  162|  2.94k|         (void)m( result );
  163|  2.94k|         return result;
  164|  2.94k|      }
  165|  2.94k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.94k|      {
   73|  2.94k|#if defined( __cpp_exceptions )
   74|  2.94k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.94k|            try {
   76|  2.94k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.94k|            }
   78|  2.94k|            catch( ... ) {
   79|  2.94k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.94k|               throw;
   81|  2.94k|            }
   82|  2.94k|         }
   83|  2.94k|         else {
   84|  2.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.94k|      {
   59|  2.94k|         return Rule::match( in );
   60|  2.94k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.34k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.34k|      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.34k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.34k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.34k|         }
  128|       |
  129|  4.34k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.34k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.34k|         }
  132|       |
  133|  4.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.30k, False: 2.03k]
  ------------------
  143|  2.30k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.30k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.30k|            }
  146|  2.30k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.30k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.30k|            }
  149|  2.30k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.30k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.30k|            }
  152|  2.30k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.30k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.30k|            }
  155|  2.30k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.30k, False: 2.03k]
  ------------------
  157|  2.30k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.30k|         }
  159|  2.03k|         else {
  160|  2.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.03k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|  4.34k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.34k|            try {
   76|  4.34k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.34k|            }
   78|  4.34k|            catch( ... ) {
   79|  4.34k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.34k|               throw;
   81|  4.34k|            }
   82|  4.34k|         }
   83|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.34k|      {
   59|  4.34k|         return Rule::match( in );
   60|  4.34k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.54k|   {
  104|  4.54k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.54k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.54k|      }
  107|  4.54k|      else {
  108|  4.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.54k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  4.54k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  4.54k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  4.54k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  4.54k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  4.54k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  4.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.54k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  4.54k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.54k|         }
  128|       |
  129|  4.54k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  4.54k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.54k|         }
  132|       |
  133|  4.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  4.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.54k, False: 0]
  ------------------
  143|  4.54k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  4.54k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.54k|            }
  146|  4.54k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  4.54k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.54k|            }
  149|  4.54k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  4.54k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.54k|            }
  152|  4.54k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  4.54k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.54k|            }
  155|  4.54k|         }
  156|  4.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.54k, False: 0]
  ------------------
  157|  4.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.54k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.54k|         (void)m( result );
  163|  4.54k|         return result;
  164|  4.54k|      }
  165|  4.54k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.54k|      {
   73|  4.54k|#if defined( __cpp_exceptions )
   74|  4.54k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  4.54k|            try {
   76|  4.54k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  4.54k|            }
   78|  4.54k|            catch( ... ) {
   79|  4.54k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  4.54k|               throw;
   81|  4.54k|            }
   82|  4.54k|         }
   83|  4.54k|         else {
   84|  4.54k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.54k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.54k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.54k|      {
   44|  4.54k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.54k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.30k|   {
  104|  2.30k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.30k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.30k|      }
  107|  2.30k|      else {
  108|  2.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.30k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.30k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.30k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.30k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.30k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.30k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.30k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.30k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.30k|         }
  128|       |
  129|  2.30k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.30k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.30k|         }
  132|       |
  133|  2.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.24k, False: 64]
  ------------------
  143|  2.24k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.24k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.24k|            }
  146|  2.24k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.24k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.24k|            }
  149|  2.24k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.24k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.24k|            }
  152|  2.24k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.24k|            }
  155|  2.24k|         }
  156|  2.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.24k, False: 64]
  ------------------
  157|  2.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.24k|         }
  159|     64|         else {
  160|     64|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     64|         }
  162|  2.30k|         (void)m( result );
  163|  2.30k|         return result;
  164|  2.30k|      }
  165|  2.30k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.30k|      {
   73|  2.30k|#if defined( __cpp_exceptions )
   74|  2.30k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.30k|            try {
   76|  2.30k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.30k|            }
   78|  2.30k|            catch( ... ) {
   79|  2.30k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.30k|               throw;
   81|  2.30k|            }
   82|  2.30k|         }
   83|  2.30k|         else {
   84|  2.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.30k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.30k|      {
   44|  2.30k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.30k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.25k|   {
  104|  2.25k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.25k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.25k|      }
  107|  2.25k|      else {
  108|  2.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  2.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  2.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  2.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  2.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  2.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  2.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.25k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  2.25k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.25k|         }
  128|       |
  129|  2.25k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  2.25k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.25k|         }
  132|       |
  133|  2.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.25k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  2.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.25k|         if( result ) {
  143|  2.25k|            if constexpr( has_apply_void ) {
  144|  2.25k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.25k|            }
  146|  2.25k|            else if constexpr( has_apply_bool ) {
  147|  2.25k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.25k|            }
  149|  2.25k|            else if constexpr( has_apply0_void ) {
  150|  2.25k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.25k|            }
  152|  2.25k|            else if constexpr( has_apply0_bool ) {
  153|  2.25k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.25k|            }
  155|  2.25k|         }
  156|  2.25k|         if( result ) {
  157|  2.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.25k|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|  2.25k|         (void)m( result );
  163|  2.25k|         return result;
  164|  2.25k|      }
  165|  2.25k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.25k|      {
   44|  2.25k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.25k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.59k|   {
  104|  4.59k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  4.59k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  4.59k|      }
  107|  4.59k|      else {
  108|  4.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  4.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  4.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  4.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  4.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  4.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  4.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  4.59k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  4.59k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  4.59k|         }
  128|       |
  129|  4.59k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  4.59k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  4.59k|         }
  132|       |
  133|  4.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  4.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.59k|         if( result ) {
  143|  4.59k|            if constexpr( has_apply_void ) {
  144|  4.59k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  4.59k|            }
  146|  4.59k|            else if constexpr( has_apply_bool ) {
  147|  4.59k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  4.59k|            }
  149|  4.59k|            else if constexpr( has_apply0_void ) {
  150|  4.59k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  4.59k|            }
  152|  4.59k|            else if constexpr( has_apply0_bool ) {
  153|  4.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.59k|            }
  155|  4.59k|         }
  156|  4.59k|         if( result ) {
  157|  4.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.59k|         }
  159|  4.59k|         else {
  160|  4.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.59k|         }
  162|  4.59k|         (void)m( result );
  163|  4.59k|         return result;
  164|  4.59k|      }
  165|  4.59k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.59k|      {
   44|  4.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.59k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.24k|   {
  104|  2.24k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  2.24k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  2.24k|      }
  107|  2.24k|      else {
  108|  2.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.24k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  2.24k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  2.24k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  2.24k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  2.24k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  2.24k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  2.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.24k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  2.24k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  2.24k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  2.24k|         }
  128|       |
  129|  2.24k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  2.24k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  2.24k|         }
  132|       |
  133|  2.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.24k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  2.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.13k, False: 112]
  ------------------
  143|  2.13k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  2.13k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  2.13k|            }
  146|  2.13k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  2.13k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  2.13k|            }
  149|  2.13k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  2.13k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  2.13k|            }
  152|  2.13k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  2.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.13k|            }
  155|  2.13k|         }
  156|  2.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.13k, False: 112]
  ------------------
  157|  2.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.13k|         }
  159|    112|         else {
  160|    112|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    112|         }
  162|  2.24k|         (void)m( result );
  163|  2.24k|         return result;
  164|  2.24k|      }
  165|  2.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.24k|      {
   73|  2.24k|#if defined( __cpp_exceptions )
   74|  2.24k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  2.24k|            try {
   76|  2.24k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  2.24k|            }
   78|  2.24k|            catch( ... ) {
   79|  2.24k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  2.24k|               throw;
   81|  2.24k|            }
   82|  2.24k|         }
   83|  2.24k|         else {
   84|  2.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.24k|      {
   59|  2.24k|         return Rule::match( in );
   60|  2.24k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.56k|   {
  104|  7.56k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.56k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.56k|      }
  107|  7.56k|      else {
  108|  7.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.56k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.56k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.56k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.56k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.56k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.56k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.56k|         }
  128|       |
  129|  7.56k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.56k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.56k|         }
  132|       |
  133|  7.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.21k, False: 1.35k]
  ------------------
  143|  6.21k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.21k|            }
  146|  6.21k|            else if constexpr( has_apply_bool ) {
  147|  6.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.21k|            }
  149|  6.21k|            else if constexpr( has_apply0_void ) {
  150|  6.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.21k|            }
  152|  6.21k|            else if constexpr( has_apply0_bool ) {
  153|  6.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.21k|            }
  155|  6.21k|         }
  156|  7.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.14k, False: 1.41k]
  ------------------
  157|  6.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.14k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|  7.56k|         (void)m( result );
  163|  7.56k|         return result;
  164|  7.56k|      }
  165|  7.56k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.56k|      {
   73|  7.56k|#if defined( __cpp_exceptions )
   74|  7.56k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.56k|            try {
   76|  7.56k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.56k|            }
   78|  7.56k|            catch( ... ) {
   79|  7.56k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.56k|               throw;
   81|  7.56k|            }
   82|  7.56k|         }
   83|  7.56k|         else {
   84|  7.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.56k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.56k|      {
   44|  7.56k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.56k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.56k|   {
  104|  7.56k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.56k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.56k|      }
  107|  7.56k|      else {
  108|  7.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.56k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.56k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.56k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.56k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.56k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.56k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.56k|         }
  128|       |
  129|  7.56k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.56k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.56k|         }
  132|       |
  133|  7.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.50k, False: 1.05k]
  ------------------
  143|  6.50k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.50k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.50k|            }
  146|  6.50k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.50k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.50k|            }
  149|  6.50k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.50k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.50k|            }
  152|  6.50k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.50k|            }
  155|  6.50k|         }
  156|  7.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.50k, False: 1.05k]
  ------------------
  157|  6.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.50k|         }
  159|  1.05k|         else {
  160|  1.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.05k|         }
  162|  7.56k|         (void)m( result );
  163|  7.56k|         return result;
  164|  7.56k|      }
  165|  7.56k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.56k|      {
   73|  7.56k|#if defined( __cpp_exceptions )
   74|  7.56k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.56k|            try {
   76|  7.56k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.56k|            }
   78|  7.56k|            catch( ... ) {
   79|  7.56k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.56k|               throw;
   81|  7.56k|            }
   82|  7.56k|         }
   83|  7.56k|         else {
   84|  7.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.56k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.56k|      {
   59|  7.56k|         return Rule::match( in );
   60|  7.56k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.50k|   {
  104|  6.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.50k|      }
  107|  6.50k|      else {
  108|  6.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  6.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  6.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  6.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  6.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  6.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  6.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  6.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.50k|         }
  128|       |
  129|  6.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  6.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.50k|         }
  132|       |
  133|  6.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  6.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.50k|         if( result ) {
  143|  6.50k|            if constexpr( has_apply_void ) {
  144|  6.50k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.50k|            }
  146|  6.50k|            else if constexpr( has_apply_bool ) {
  147|  6.50k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.50k|            }
  149|  6.50k|            else if constexpr( has_apply0_void ) {
  150|  6.50k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.50k|            }
  152|  6.50k|            else if constexpr( has_apply0_bool ) {
  153|  6.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.50k|            }
  155|  6.50k|         }
  156|  6.50k|         if( result ) {
  157|  6.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.50k|         }
  159|  6.50k|         else {
  160|  6.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.50k|         }
  162|  6.50k|         (void)m( result );
  163|  6.50k|         return result;
  164|  6.50k|      }
  165|  6.50k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.50k|      {
   44|  6.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.50k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.50k|   {
  104|  6.50k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  6.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  6.50k|      }
  107|  6.50k|      else {
  108|  6.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  6.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  6.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  6.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  6.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  6.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  6.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  6.50k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  6.50k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  6.50k|         }
  128|       |
  129|  6.50k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  6.50k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  6.50k|         }
  132|       |
  133|  6.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  6.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.21k, False: 295]
  ------------------
  143|  6.21k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.21k|            }
  146|  6.21k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.21k|            }
  149|  6.21k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.21k|            }
  152|  6.21k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.21k|            }
  155|  6.21k|         }
  156|  6.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.21k, False: 295]
  ------------------
  157|  6.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.21k|         }
  159|    295|         else {
  160|    295|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    295|         }
  162|  6.50k|         (void)m( result );
  163|  6.50k|         return result;
  164|  6.50k|      }
  165|  6.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.50k|      {
   73|  6.50k|#if defined( __cpp_exceptions )
   74|  6.50k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  6.50k|            try {
   76|  6.50k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  6.50k|            }
   78|  6.50k|            catch( ... ) {
   79|  6.50k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  6.50k|               throw;
   81|  6.50k|            }
   82|  6.50k|         }
   83|  6.50k|         else {
   84|  6.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.50k|      {
   44|  6.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.50k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.35M|   {
  104|  7.35M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.35M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.35M|      }
  107|  7.35M|      else {
  108|  7.35M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.35M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.35M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.35M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.35M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.35M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.35M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.35M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.35M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.35M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.35M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.35M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.35M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.35M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.35M|         }
  128|       |
  129|  7.35M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.35M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.35M|         }
  132|       |
  133|  7.35M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.35M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.35M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.35M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.35M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.35M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.35M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.35M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.21k, False: 7.34M]
  ------------------
  143|  6.21k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  6.21k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  6.21k|            }
  146|  6.21k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  6.21k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  6.21k|            }
  149|  6.21k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  6.21k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  6.21k|            }
  152|  6.21k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  6.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.21k|            }
  155|  6.21k|         }
  156|  7.35M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.21k, False: 7.34M]
  ------------------
  157|  6.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.21k|         }
  159|  7.34M|         else {
  160|  7.34M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.34M|         }
  162|  7.35M|         (void)m( result );
  163|  7.35M|         return result;
  164|  7.35M|      }
  165|  7.35M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.35M|      {
   73|  7.35M|#if defined( __cpp_exceptions )
   74|  7.35M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.35M|            try {
   76|  7.35M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.35M|            }
   78|  7.35M|            catch( ... ) {
   79|  7.35M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.35M|               throw;
   81|  7.35M|            }
   82|  7.35M|         }
   83|  7.35M|         else {
   84|  7.35M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.35M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.35M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.35M|      {
   59|  7.35M|         return Rule::match( in );
   60|  7.35M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|  7.34M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.34M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.34M|      }
  107|  7.34M|      else {
  108|  7.34M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.34M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.34M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.34M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.34M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.34M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.34M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.34M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.34M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.34M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.34M|         }
  128|       |
  129|  7.34M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.34M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.34M|         }
  132|       |
  133|  7.34M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.34M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.34M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.34M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.34M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.34M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.34M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.34M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.34M, False: 295]
  ------------------
  143|  7.34M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.34M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.34M|            }
  146|  7.34M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.34M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.34M|            }
  149|  7.34M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.34M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.34M|            }
  152|  7.34M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.34M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.34M|            }
  155|  7.34M|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.34M, False: 295]
  ------------------
  157|  7.34M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.34M|         }
  159|    295|         else {
  160|    295|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    295|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.34M|      {
   73|  7.34M|#if defined( __cpp_exceptions )
   74|  7.34M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.34M|            try {
   76|  7.34M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.34M|            }
   78|  7.34M|            catch( ... ) {
   79|  7.34M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.34M|               throw;
   81|  7.34M|            }
   82|  7.34M|         }
   83|  7.34M|         else {
   84|  7.34M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.34M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.34M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.34M|      {
   44|  7.34M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.34M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|  7.34M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.34M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.34M|      }
  107|  7.34M|      else {
  108|  7.34M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.34M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.34M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.34M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.34M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.34M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.34M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.34M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.34M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.34M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.34M|         }
  128|       |
  129|  7.34M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.34M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.34M|         }
  132|       |
  133|  7.34M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.34M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.34M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.34M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.34M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.34M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.34M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.34M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 120k, False: 7.22M]
  ------------------
  143|   120k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   120k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   120k|            }
  146|   120k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   120k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   120k|            }
  149|   120k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   120k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   120k|            }
  152|   120k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   120k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   120k|            }
  155|   120k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 120k, False: 7.22M]
  ------------------
  157|   120k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   120k|         }
  159|  7.22M|         else {
  160|  7.22M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.22M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.34M|      {
   73|  7.34M|#if defined( __cpp_exceptions )
   74|  7.34M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.34M|            try {
   76|  7.34M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.34M|            }
   78|  7.34M|            catch( ... ) {
   79|  7.34M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.34M|               throw;
   81|  7.34M|            }
   82|  7.34M|         }
   83|  7.34M|         else {
   84|  7.34M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.34M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.34M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.34M|      {
   44|  7.34M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.34M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|  7.34M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.34M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.34M|      }
  107|  7.34M|      else {
  108|  7.34M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.34M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.34M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.34M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.34M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.34M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.34M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.34M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.34M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.34M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.34M|         }
  128|       |
  129|  7.34M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.34M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.34M|         }
  132|       |
  133|  7.34M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.34M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.34M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.34M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.34M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.34M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.34M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.34M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 121k, False: 7.22M]
  ------------------
  143|   121k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   121k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   121k|            }
  146|   121k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   121k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   121k|            }
  149|   121k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   121k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   121k|            }
  152|   121k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   121k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   121k|            }
  155|   121k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 121k, False: 7.22M]
  ------------------
  157|   121k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   121k|         }
  159|  7.22M|         else {
  160|  7.22M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.22M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.34M|      {
   73|  7.34M|#if defined( __cpp_exceptions )
   74|  7.34M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.34M|            try {
   76|  7.34M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.34M|            }
   78|  7.34M|            catch( ... ) {
   79|  7.34M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.34M|               throw;
   81|  7.34M|            }
   82|  7.34M|         }
   83|  7.34M|         else {
   84|  7.34M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.34M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.34M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.34M|      {
   59|  7.34M|         return Rule::match( in );
   60|  7.34M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   121k|   {
  104|   121k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   121k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   121k|      }
  107|   121k|      else {
  108|   121k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   121k|         using iterator_t = typename ParseInput::iterator_t;
  111|   121k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|   121k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|   121k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|   121k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|   121k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|   121k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|   121k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   121k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   121k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   121k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   121k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|   121k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   121k|         }
  128|       |
  129|   121k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|   121k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   121k|         }
  132|       |
  133|   121k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   121k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   121k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   121k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|   121k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   121k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   121k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   121k|         if( result ) {
  143|   121k|            if constexpr( has_apply_void ) {
  144|   121k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   121k|            }
  146|   121k|            else if constexpr( has_apply_bool ) {
  147|   121k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   121k|            }
  149|   121k|            else if constexpr( has_apply0_void ) {
  150|   121k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   121k|            }
  152|   121k|            else if constexpr( has_apply0_bool ) {
  153|   121k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   121k|            }
  155|   121k|         }
  156|   121k|         if( result ) {
  157|   121k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   121k|         }
  159|   121k|         else {
  160|   121k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   121k|         }
  162|   121k|         (void)m( result );
  163|   121k|         return result;
  164|   121k|      }
  165|   121k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   121k|      {
   44|   121k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   121k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   121k|   {
  104|   121k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   121k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   121k|      }
  107|   121k|      else {
  108|   121k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   121k|         using iterator_t = typename ParseInput::iterator_t;
  111|   121k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   121k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   121k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   121k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   121k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   121k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   121k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   121k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   121k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   121k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   121k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   121k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   121k|         }
  128|       |
  129|   121k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   121k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   121k|         }
  132|       |
  133|   121k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   121k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   121k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   121k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   121k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   121k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   121k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   121k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 120k, False: 100]
  ------------------
  143|   120k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|   120k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|   120k|            }
  146|   120k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|   120k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|   120k|            }
  149|   120k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|   120k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|   120k|            }
  152|   120k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|   120k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   120k|            }
  155|   120k|         }
  156|   121k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 120k, False: 100]
  ------------------
  157|   120k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   120k|         }
  159|    100|         else {
  160|    100|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    100|         }
  162|   121k|         (void)m( result );
  163|   121k|         return result;
  164|   121k|      }
  165|   121k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   121k|      {
   73|   121k|#if defined( __cpp_exceptions )
   74|   121k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   121k|            try {
   76|   121k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   121k|            }
   78|   121k|            catch( ... ) {
   79|   121k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   121k|               throw;
   81|   121k|            }
   82|   121k|         }
   83|   121k|         else {
   84|   121k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   121k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   121k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   121k|      {
   44|   121k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   121k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   121k|   {
  104|   121k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   121k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   121k|      }
  107|   121k|      else {
  108|   121k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   121k|         using iterator_t = typename ParseInput::iterator_t;
  111|   121k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   121k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   121k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   121k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   121k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   121k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   121k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   121k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   121k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   121k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   121k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   121k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   121k|         }
  128|       |
  129|   121k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   121k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   121k|         }
  132|       |
  133|   121k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   121k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   121k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   121k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   121k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   121k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   121k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   121k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.2k, False: 90.7k]
  ------------------
  143|  30.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.2k|            }
  146|  30.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.2k|            }
  149|  30.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.2k|            }
  152|  30.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.2k|            }
  155|  30.2k|         }
  156|   121k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.2k, False: 90.7k]
  ------------------
  157|  30.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.2k|         }
  159|  90.7k|         else {
  160|  90.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  90.7k|         }
  162|   121k|         (void)m( result );
  163|   121k|         return result;
  164|   121k|      }
  165|   121k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   121k|      {
   73|   121k|#if defined( __cpp_exceptions )
   74|   121k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   121k|            try {
   76|   121k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   121k|            }
   78|   121k|            catch( ... ) {
   79|   121k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   121k|               throw;
   81|   121k|            }
   82|   121k|         }
   83|   121k|         else {
   84|   121k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   121k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   121k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   121k|      {
   44|   121k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   121k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   121k|   {
  104|   121k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   121k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   121k|      }
  107|   121k|      else {
  108|   121k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   121k|         using iterator_t = typename ParseInput::iterator_t;
  111|   121k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   121k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   121k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   121k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   121k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   121k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   121k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   121k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   121k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   121k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   121k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   121k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   121k|         }
  128|       |
  129|   121k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   121k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   121k|         }
  132|       |
  133|   121k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   121k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   121k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   121k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   121k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   121k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   121k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   121k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.3k, False: 90.7k]
  ------------------
  143|  30.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.3k|            }
  146|  30.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.3k|            }
  149|  30.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.3k|            }
  152|  30.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.3k|            }
  155|  30.3k|         }
  156|   121k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.3k, False: 90.7k]
  ------------------
  157|  30.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.3k|         }
  159|  90.7k|         else {
  160|  90.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  90.7k|         }
  162|   121k|         (void)m( result );
  163|   121k|         return result;
  164|   121k|      }
  165|   121k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   121k|      {
   73|   121k|#if defined( __cpp_exceptions )
   74|   121k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   121k|            try {
   76|   121k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   121k|            }
   78|   121k|            catch( ... ) {
   79|   121k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   121k|               throw;
   81|   121k|            }
   82|   121k|         }
   83|   121k|         else {
   84|   121k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   121k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   121k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   121k|      {
   59|   121k|         return Rule::match( in );
   60|   121k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  30.3k|   {
  104|  30.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.3k|      }
  107|  30.3k|      else {
  108|  30.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  30.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  30.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  30.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  30.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  30.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  30.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  30.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.3k|         }
  128|       |
  129|  30.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  30.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.3k|         }
  132|       |
  133|  30.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  30.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.3k|         if( result ) {
  143|  30.3k|            if constexpr( has_apply_void ) {
  144|  30.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.3k|            }
  146|  30.3k|            else if constexpr( has_apply_bool ) {
  147|  30.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.3k|            }
  149|  30.3k|            else if constexpr( has_apply0_void ) {
  150|  30.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.3k|            }
  152|  30.3k|            else if constexpr( has_apply0_bool ) {
  153|  30.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.3k|            }
  155|  30.3k|         }
  156|  30.3k|         if( result ) {
  157|  30.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.3k|         }
  159|  30.3k|         else {
  160|  30.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.3k|         }
  162|  30.3k|         (void)m( result );
  163|  30.3k|         return result;
  164|  30.3k|      }
  165|  30.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.3k|      {
   44|  30.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.3k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  30.3k|   {
  104|  30.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  30.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  30.3k|      }
  107|  30.3k|      else {
  108|  30.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  30.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  30.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  30.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  30.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  30.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  30.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  30.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  30.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  30.3k|         }
  128|       |
  129|  30.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  30.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  30.3k|         }
  132|       |
  133|  30.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  30.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.2k, False: 38]
  ------------------
  143|  30.2k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  30.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  30.2k|            }
  146|  30.2k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  30.2k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  30.2k|            }
  149|  30.2k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  30.2k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  30.2k|            }
  152|  30.2k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  30.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.2k|            }
  155|  30.2k|         }
  156|  30.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.2k, False: 38]
  ------------------
  157|  30.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.2k|         }
  159|     38|         else {
  160|     38|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     38|         }
  162|  30.3k|         (void)m( result );
  163|  30.3k|         return result;
  164|  30.3k|      }
  165|  30.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  30.3k|      {
   73|  30.3k|#if defined( __cpp_exceptions )
   74|  30.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  30.3k|            try {
   76|  30.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  30.3k|            }
   78|  30.3k|            catch( ... ) {
   79|  30.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  30.3k|               throw;
   81|  30.3k|            }
   82|  30.3k|         }
   83|  30.3k|         else {
   84|  30.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  30.3k|      {
   44|  30.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  60.6k|   {
  104|  60.6k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  60.6k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  60.6k|      }
  107|  60.6k|      else {
  108|  60.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  60.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  60.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  60.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  60.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  60.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  60.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  60.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  60.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  60.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  60.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  60.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  60.6k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  60.6k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  60.6k|         }
  128|       |
  129|  60.6k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  60.6k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  60.6k|         }
  132|       |
  133|  60.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  60.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  60.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  60.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  60.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  60.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  60.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  60.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 60.5k, False: 38]
  ------------------
  143|  60.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  60.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  60.5k|            }
  146|  60.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  60.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  60.5k|            }
  149|  60.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  60.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  60.5k|            }
  152|  60.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  60.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  60.5k|            }
  155|  60.5k|         }
  156|  60.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 60.5k, False: 38]
  ------------------
  157|  60.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  60.5k|         }
  159|     38|         else {
  160|     38|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     38|         }
  162|  60.6k|         (void)m( result );
  163|  60.6k|         return result;
  164|  60.6k|      }
  165|  60.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  60.6k|      {
   73|  60.6k|#if defined( __cpp_exceptions )
   74|  60.6k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  60.6k|            try {
   76|  60.6k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  60.6k|            }
   78|  60.6k|            catch( ... ) {
   79|  60.6k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  60.6k|               throw;
   81|  60.6k|            }
   82|  60.6k|         }
   83|  60.6k|         else {
   84|  60.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  60.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  60.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  60.6k|      {
   59|  60.6k|         return Rule::match( in );
   60|  60.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  90.7k|   {
  104|  90.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  90.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  90.7k|      }
  107|  90.7k|      else {
  108|  90.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  90.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  90.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  90.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  90.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  90.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  90.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  90.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  90.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  90.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  90.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  90.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  90.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  90.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  90.7k|         }
  128|       |
  129|  90.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  90.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  90.7k|         }
  132|       |
  133|  90.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  90.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  90.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  90.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  90.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  90.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  90.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  90.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.3k, False: 57.3k]
  ------------------
  143|  33.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  33.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  33.3k|            }
  146|  33.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  33.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  33.3k|            }
  149|  33.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  33.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  33.3k|            }
  152|  33.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  33.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.3k|            }
  155|  33.3k|         }
  156|  90.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.3k, False: 57.3k]
  ------------------
  157|  33.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.3k|         }
  159|  57.3k|         else {
  160|  57.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  57.3k|         }
  162|  90.7k|         (void)m( result );
  163|  90.7k|         return result;
  164|  90.7k|      }
  165|  90.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  90.7k|      {
   73|  90.7k|#if defined( __cpp_exceptions )
   74|  90.7k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  90.7k|            try {
   76|  90.7k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  90.7k|            }
   78|  90.7k|            catch( ... ) {
   79|  90.7k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  90.7k|               throw;
   81|  90.7k|            }
   82|  90.7k|         }
   83|  90.7k|         else {
   84|  90.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  90.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  90.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  90.7k|      {
   44|  90.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  90.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   138k|   {
  104|   138k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|   138k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|   138k|      }
  107|   138k|      else {
  108|   138k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   138k|         using iterator_t = typename ParseInput::iterator_t;
  111|   138k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|   138k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|   138k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|   138k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|   138k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|   138k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|   138k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   138k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   138k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   138k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|   138k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|   138k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|   138k|         }
  128|       |
  129|   138k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|   138k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|   138k|         }
  132|       |
  133|   138k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   138k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   138k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   138k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|   138k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   138k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   138k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   138k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 56.9k, False: 81.6k]
  ------------------
  143|  56.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  56.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  56.9k|            }
  146|  56.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  56.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  56.9k|            }
  149|  56.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  56.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  56.9k|            }
  152|  56.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  56.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  56.9k|            }
  155|  56.9k|         }
  156|   138k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 56.9k, False: 81.6k]
  ------------------
  157|  56.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  56.9k|         }
  159|  81.6k|         else {
  160|  81.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  81.6k|         }
  162|   138k|         (void)m( result );
  163|   138k|         return result;
  164|   138k|      }
  165|   138k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   138k|      {
   73|   138k|#if defined( __cpp_exceptions )
   74|   138k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|   138k|            try {
   76|   138k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|   138k|            }
   78|   138k|            catch( ... ) {
   79|   138k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|   138k|               throw;
   81|   138k|            }
   82|   138k|         }
   83|   138k|         else {
   84|   138k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   138k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   138k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   138k|      {
   59|   138k|         return Rule::match( in );
   60|   138k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  33.3k|   {
  104|  33.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  33.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  33.3k|      }
  107|  33.3k|      else {
  108|  33.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  33.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  33.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  33.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  33.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  33.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  33.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  33.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  33.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  33.3k|         }
  128|       |
  129|  33.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  33.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  33.3k|         }
  132|       |
  133|  33.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  33.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.3k|         if( result ) {
  143|  33.3k|            if constexpr( has_apply_void ) {
  144|  33.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  33.3k|            }
  146|  33.3k|            else if constexpr( has_apply_bool ) {
  147|  33.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  33.3k|            }
  149|  33.3k|            else if constexpr( has_apply0_void ) {
  150|  33.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  33.3k|            }
  152|  33.3k|            else if constexpr( has_apply0_bool ) {
  153|  33.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.3k|            }
  155|  33.3k|         }
  156|  33.3k|         if( result ) {
  157|  33.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.3k|         }
  159|  33.3k|         else {
  160|  33.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.3k|         }
  162|  33.3k|         (void)m( result );
  163|  33.3k|         return result;
  164|  33.3k|      }
  165|  33.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.3k|      {
   44|  33.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.3k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  33.3k|   {
  104|  33.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  33.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  33.3k|      }
  107|  33.3k|      else {
  108|  33.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  33.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  33.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  33.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  33.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  33.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  33.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  33.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  33.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  33.3k|         }
  128|       |
  129|  33.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  33.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  33.3k|         }
  132|       |
  133|  33.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  33.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.3k, False: 0]
  ------------------
  143|  33.3k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  33.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  33.3k|            }
  146|  33.3k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  33.3k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  33.3k|            }
  149|  33.3k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  33.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  33.3k|            }
  152|  33.3k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  33.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.3k|            }
  155|  33.3k|         }
  156|  33.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.3k, False: 0]
  ------------------
  157|  33.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.3k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  33.3k|         (void)m( result );
  163|  33.3k|         return result;
  164|  33.3k|      }
  165|  33.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  33.3k|      {
   73|  33.3k|#if defined( __cpp_exceptions )
   74|  33.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  33.3k|            try {
   76|  33.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  33.3k|            }
   78|  33.3k|            catch( ... ) {
   79|  33.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  33.3k|               throw;
   81|  33.3k|            }
   82|  33.3k|         }
   83|  33.3k|         else {
   84|  33.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.3k|      {
   44|  33.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  57.3k|   {
  104|  57.3k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  57.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  57.3k|      }
  107|  57.3k|      else {
  108|  57.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  57.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  57.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  57.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  57.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  57.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  57.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  57.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  57.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  57.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  57.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  57.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  57.3k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  57.3k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  57.3k|         }
  128|       |
  129|  57.3k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  57.3k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  57.3k|         }
  132|       |
  133|  57.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  57.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  57.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  57.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  57.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  57.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  57.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  57.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 55.5k, False: 1.80k]
  ------------------
  143|  55.5k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  55.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  55.5k|            }
  146|  55.5k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  55.5k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  55.5k|            }
  149|  55.5k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  55.5k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  55.5k|            }
  152|  55.5k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  55.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  55.5k|            }
  155|  55.5k|         }
  156|  57.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 55.5k, False: 1.80k]
  ------------------
  157|  55.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  55.5k|         }
  159|  1.80k|         else {
  160|  1.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.80k|         }
  162|  57.3k|         (void)m( result );
  163|  57.3k|         return result;
  164|  57.3k|      }
  165|  57.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  57.3k|      {
   73|  57.3k|#if defined( __cpp_exceptions )
   74|  57.3k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  57.3k|            try {
   76|  57.3k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  57.3k|            }
   78|  57.3k|            catch( ... ) {
   79|  57.3k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  57.3k|               throw;
   81|  57.3k|            }
   82|  57.3k|         }
   83|  57.3k|         else {
   84|  57.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  57.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  57.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  57.3k|      {
   59|  57.3k|         return Rule::match( in );
   60|  57.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.80k|   {
  104|  1.80k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  1.80k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  1.80k|      }
  107|  1.80k|      else {
  108|  1.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.80k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  1.80k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  1.80k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  1.80k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  1.80k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  1.80k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  1.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.80k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  1.80k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  1.80k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  1.80k|         }
  128|       |
  129|  1.80k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  1.80k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  1.80k|         }
  132|       |
  133|  1.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.80k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  1.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.73k, False: 62]
  ------------------
  143|  1.73k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  1.73k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  1.73k|            }
  146|  1.73k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  1.73k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  1.73k|            }
  149|  1.73k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  1.73k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  1.73k|            }
  152|  1.73k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  1.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.73k|            }
  155|  1.73k|         }
  156|  1.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.73k, False: 62]
  ------------------
  157|  1.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.73k|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|  1.80k|         (void)m( result );
  163|  1.80k|         return result;
  164|  1.80k|      }
  165|  1.80k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.80k|      {
   73|  1.80k|#if defined( __cpp_exceptions )
   74|  1.80k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  1.80k|            try {
   76|  1.80k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  1.80k|            }
   78|  1.80k|            catch( ... ) {
   79|  1.80k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  1.80k|               throw;
   81|  1.80k|            }
   82|  1.80k|         }
   83|  1.80k|         else {
   84|  1.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.80k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.80k|      {
   59|  1.80k|         return Rule::match( in );
   60|  1.80k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.22M|   {
  104|  7.22M|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  7.22M|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  7.22M|      }
  107|  7.22M|      else {
  108|  7.22M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.22M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.22M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  7.22M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  7.22M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  7.22M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  7.22M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  7.22M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  7.22M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.22M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.22M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.22M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  7.22M|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  7.22M|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  7.22M|         }
  128|       |
  129|  7.22M|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  7.22M|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  7.22M|         }
  132|       |
  133|  7.22M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.22M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.22M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.22M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  7.22M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.22M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.22M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.22M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.22M, False: 195]
  ------------------
  143|  7.22M|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  7.22M|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  7.22M|            }
  146|  7.22M|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  7.22M|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  7.22M|            }
  149|  7.22M|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  7.22M|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  7.22M|            }
  152|  7.22M|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  7.22M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.22M|            }
  155|  7.22M|         }
  156|  7.22M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.22M, False: 195]
  ------------------
  157|  7.22M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.22M|         }
  159|    195|         else {
  160|    195|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    195|         }
  162|  7.22M|         (void)m( result );
  163|  7.22M|         return result;
  164|  7.22M|      }
  165|  7.22M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.22M|      {
   73|  7.22M|#if defined( __cpp_exceptions )
   74|  7.22M|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  7.22M|            try {
   76|  7.22M|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  7.22M|            }
   78|  7.22M|            catch( ... ) {
   79|  7.22M|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  7.22M|               throw;
   81|  7.22M|            }
   82|  7.22M|         }
   83|  7.22M|         else {
   84|  7.22M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.22M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.22M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.22M|      {
   59|  7.22M|         return Rule::match( in );
   60|  7.22M|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  28.7k|   {
  104|  28.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  28.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  28.7k|      }
  107|  28.7k|      else {
  108|  28.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  28.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  28.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  28.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  28.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  28.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  28.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  28.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  28.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  28.7k|         }
  128|       |
  129|  28.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  28.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  28.7k|         }
  132|       |
  133|  28.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  28.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  28.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.7k|         if( result ) {
  143|  28.7k|            if constexpr( has_apply_void ) {
  144|  28.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  28.7k|            }
  146|  28.7k|            else if constexpr( has_apply_bool ) {
  147|  28.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  28.7k|            }
  149|  28.7k|            else if constexpr( has_apply0_void ) {
  150|  28.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  28.7k|            }
  152|  28.7k|            else if constexpr( has_apply0_bool ) {
  153|  28.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.7k|            }
  155|  28.7k|         }
  156|  28.7k|         if( result ) {
  157|  28.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.7k|         }
  159|  28.7k|         else {
  160|  28.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.7k|         }
  162|  28.7k|         (void)m( result );
  163|  28.7k|         return result;
  164|  28.7k|      }
  165|  28.7k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  28.7k|      {
   44|  28.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.7k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  31.7k|   {
  104|  31.7k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  31.7k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  31.7k|      }
  107|  31.7k|      else {
  108|  31.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|  31.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|  31.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|  31.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|  31.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|  31.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|  31.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  31.7k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|  31.7k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  31.7k|         }
  128|       |
  129|  31.7k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|  31.7k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  31.7k|         }
  132|       |
  133|  31.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  31.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|  31.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.7k|         if( result ) {
  143|  31.7k|            if constexpr( has_apply_void ) {
  144|  31.7k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  31.7k|            }
  146|  31.7k|            else if constexpr( has_apply_bool ) {
  147|  31.7k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  31.7k|            }
  149|  31.7k|            else if constexpr( has_apply0_void ) {
  150|  31.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  31.7k|            }
  152|  31.7k|            else if constexpr( has_apply0_bool ) {
  153|  31.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.7k|            }
  155|  31.7k|         }
  156|  31.7k|         if( result ) {
  157|  31.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.7k|         }
  159|  31.7k|         else {
  160|  31.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.7k|         }
  162|  31.7k|         (void)m( result );
  163|  31.7k|         return result;
  164|  31.7k|      }
  165|  31.7k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  31.7k|      {
   44|  31.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.7k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  38.9k|   {
  104|  38.9k|      if constexpr( !Control< Rule >::enable ) {
  ------------------
  |  Branch (104:21): [Folded - Ignored]
  ------------------
  105|  38.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|  38.9k|      }
  107|  38.9k|      else {
  108|  38.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded - Ignored]
  |  Branch (111:59): [Folded - Ignored]
  ------------------
  112|  38.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded - Ignored]
  |  Branch (112:59): [Folded - Ignored]
  ------------------
  113|  38.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded - Ignored]
  |  Branch (113:55): [Folded - Ignored]
  ------------------
  114|       |
  115|  38.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded - Ignored]
  |  Branch (115:60): [Folded - Ignored]
  ------------------
  116|  38.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded - Ignored]
  |  Branch (116:60): [Folded - Ignored]
  ------------------
  117|  38.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded - Ignored]
  |  Branch (117:57): [Folded - Ignored]
  ------------------
  118|       |
  119|  38.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|  38.9k|         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  ------------------
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:24): [Folded - Ignored]
  |  Branch (125:38): [Folded - Ignored]
  ------------------
  126|  38.9k|            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|  38.9k|         }
  128|       |
  129|  38.9k|         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  ------------------
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:24): [Folded - Ignored]
  |  Branch (129:39): [Folded - Ignored]
  ------------------
  130|  38.9k|            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|  38.9k|         }
  132|       |
  133|  38.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded - Ignored]
  |  Branch (137:51): [Folded - Ignored]
  ------------------
  138|       |
  139|  38.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.9k, False: 0]
  ------------------
  143|  38.9k|            if constexpr( has_apply_void ) {
  ------------------
  |  Branch (143:27): [Folded - Ignored]
  ------------------
  144|  38.9k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|  38.9k|            }
  146|  38.9k|            else if constexpr( has_apply_bool ) {
  ------------------
  |  Branch (146:32): [Folded - Ignored]
  ------------------
  147|  38.9k|               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|  38.9k|            }
  149|  38.9k|            else if constexpr( has_apply0_void ) {
  ------------------
  |  Branch (149:32): [Folded - Ignored]
  ------------------
  150|  38.9k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|  38.9k|            }
  152|  38.9k|            else if constexpr( has_apply0_bool ) {
  ------------------
  |  Branch (152:32): [Folded - Ignored]
  ------------------
  153|  38.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.9k|            }
  155|  38.9k|         }
  156|  38.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.9k, False: 0]
  ------------------
  157|  38.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  38.9k|         (void)m( result );
  163|  38.9k|         return result;
  164|  38.9k|      }
  165|  38.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  38.9k|      {
   73|  38.9k|#if defined( __cpp_exceptions )
   74|  38.9k|         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
  ------------------
  |  Branch (74:24): [Folded - Ignored]
  ------------------
   75|  38.9k|            try {
   76|  38.9k|               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|  38.9k|            }
   78|  38.9k|            catch( ... ) {
   79|  38.9k|               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|  38.9k|               throw;
   81|  38.9k|            }
   82|  38.9k|         }
   83|  38.9k|         else {
   84|  38.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS5_19rule_parser_actionsENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.9k|      {
   44|  38.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.9k|      }

_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4markILNS0_11rewind_modeE2EEENS0_8internal6markerINSG_8iteratorEXT_EEEv:
  338|   429M|      {
  339|   429M|         return internal::marker< iterator_t, M >( iterator() );
  340|   429M|      }
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE8iteratorEv:
  308|   439M|      {
  309|   439M|         return this->m_current;
  310|   439M|      }
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4markILNS0_11rewind_modeE1EEENS0_8internal6markerINSG_8iteratorEXT_EEEv:
  338|  8.33M|      {
  339|  8.33M|         return internal::marker< iterator_t, M >( iterator() );
  340|  8.33M|      }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE5emptyEv:
  288|   259M|      {
  289|   259M|         return this->current() == this->end();
  290|   259M|      }
_ZNK3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE7currentEv:
   69|   519M|         {
   70|   519M|            return m_current.data;
   71|   519M|         }
_ZNK3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE3endEm:
   79|   260M|         {
   80|   260M|            return m_end;
   81|   260M|         }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE9peek_charEm:
  298|   257M|      {
  299|   257M|         return this->current()[ offset ];
  300|   257M|      }
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE17bump_in_this_lineEm:
  104|  97.2M|         {
  105|  97.2M|            internal::bump_in_this_line( m_current, in_count );
  106|  97.2M|         }
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE4bumpEm:
   99|  1.63M|         {
  100|  1.63M|            internal::bump( m_current, in_count, Eol::ch );
  101|  1.63M|         }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE8positionEv:
  328|  6.72k|      {
  329|  6.72k|         return position( iterator() );
  330|  6.72k|      }
_ZNK3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE8positionERKNS1_8iteratorE:
  114|  8.77k|         {
  115|  8.77k|            return TAO_PEGTL_NAMESPACE::position( it, m_source );
  ------------------
  |  |    8|  8.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
  116|  8.77k|         }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE8iteratorEv:
  313|  6.72k|      {
  314|  6.72k|         return this->m_current;
  315|  6.72k|      }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4sizeEm:
  293|   565k|      {
  294|   565k|         return std::size_t( this->end() - this->current() );
  295|   565k|      }
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4markILNS0_11rewind_modeE0EEENS0_8internal6markerINSG_8iteratorEXT_EEEv:
  338|  1.65M|      {
  339|  1.65M|         return internal::marker< iterator_t, M >( iterator() );
  340|  1.65M|      }
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEED2Ev:
   63|  38.3k|         ~memory_input_base() = default;
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEC2IRKSC_EEPKcmOT_:
  249|  38.3k|      {}
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEC2IRKSD_EEPKcSJ_OT_:
   58|  38.3k|         {}

_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.3k|      {
   88|  38.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  38.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  38.3k|         }
   91|  38.3k|         else {
   92|  38.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.3k|         }
   94|  38.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.3k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  77.3k|      {
   88|  77.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  77.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  77.3k|         }
   91|  77.3k|         else {
   92|  77.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  77.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  77.3k|         }
   94|  77.3k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.24M|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  43.5k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.19M|      {}
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS5_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  47.7k|      {
   88|  47.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.7k|         }
   91|  47.7k|         else {
   92|  47.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.7k|         }
   94|  47.7k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   36|  47.7k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  47.7k|      {
   88|  47.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.7k|         }
   91|  47.7k|         else {
   92|  47.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.7k|         }
   94|  47.7k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  47.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  86.7k|      {
   88|  86.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  86.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  86.7k|         }
   91|  86.7k|         else {
   92|  86.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.7k|         }
   94|  86.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  86.7k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  86.7k|      {
   88|  86.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  86.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  86.7k|         }
   91|  86.7k|         else {
   92|  86.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.7k|         }
   94|  86.7k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   139k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   188k|      {
   88|   188k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   188k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   188k|         }
   91|   188k|         else {
   92|   188k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   188k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   188k|         }
   94|   188k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  3.81M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.86M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.94M|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   139k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSJ_4RuleEEEEbRT3_DpOT4_:
   87|  86.7k|      {
   88|  86.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  86.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  86.7k|         }
   91|  86.7k|         else {
   92|  86.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.7k|         }
   94|  86.7k|      }
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  86.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  86.7k|      {
   88|  86.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  86.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  86.7k|         }
   91|  86.7k|         else {
   92|  86.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.7k|         }
   94|  86.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  86.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  14.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  72.7k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNSI_4RuleEEEEbRT3_DpOT4_:
   87|  14.0k|      {
   88|  14.0k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  14.0k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  14.0k|         }
   91|  14.0k|         else {
   92|  14.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.0k|         }
   94|  14.0k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSF_4RuleEEEEbRT3_DpOT4_:
   87|  14.0k|      {
   88|  14.0k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  14.0k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  14.0k|         }
   91|  14.0k|         else {
   92|  14.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.0k|         }
   94|  14.0k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  14.0k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  1.16M|      {
   88|  1.16M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.16M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.16M|         }
   91|  1.16M|         else {
   92|  1.16M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.16M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.16M|         }
   94|  1.16M|      }
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.16M|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.16M|      {
   88|  1.16M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.16M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.16M|         }
   91|  1.16M|         else {
   92|  1.16M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.16M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.16M|         }
   94|  1.16M|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.16M|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE0ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  1.16M|      {
   88|  1.16M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.16M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.16M|         }
   91|  1.16M|         else {
   92|  1.16M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.16M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.16M|         }
   94|  1.16M|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.15M|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  14.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.15M|      {
   88|  1.15M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.15M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.15M|         }
   91|  1.15M|         else {
   92|  1.15M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.15M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.15M|         }
   94|  1.15M|      }
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.15M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.15M|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.15M|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  14.0k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  14.0k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  14.0k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  72.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE6apply0INS3_19rule_parser_actionsENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE6apply0spfp0_EERKT0_DpOT1_:
   74|  14.0k|      {
   75|  14.0k|         return Action< Rule >::apply0( st... );
   76|  14.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  14.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  72.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  47.7k|      {
   88|  47.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.7k|         }
   91|  47.7k|         else {
   92|  47.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.7k|         }
   94|  47.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  47.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  47.7k|      {
   88|  47.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.7k|         }
   91|  47.7k|         else {
   92|  47.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.7k|         }
   94|  47.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  47.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  47.7k|      {
   88|  47.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.7k|         }
   91|  47.7k|         else {
   92|  47.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.7k|         }
   94|  47.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  47.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  36.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.7k|      {
   88|  11.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  11.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  11.7k|         }
   91|  11.7k|         else {
   92|  11.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.7k|         }
   94|  11.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.99k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.75k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.75k|      {
   88|  7.75k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.75k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.75k|         }
   91|  7.75k|         else {
   92|  7.75k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.75k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.75k|         }
   94|  7.75k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  7.75k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    264|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.48k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.48k|      {
   88|  7.48k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.48k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.48k|         }
   91|  7.48k|         else {
   92|  7.48k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.48k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.48k|         }
   94|  7.48k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  7.48k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.66k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  4.82k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.82k|      {
   88|  4.82k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.82k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.82k|         }
   91|  4.82k|         else {
   92|  4.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.82k|         }
   94|  4.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  4.82k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    508|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  4.31k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5applyINS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  43.4k|      {
   65|  43.4k|         const typename ParseInput::action_t action_input( begin, in );
   66|  43.4k|         return Action< Rule >::apply( action_input, st... );
   67|  43.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  43.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  4.31k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS8_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  43.4k|      {
   88|  43.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  43.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  43.4k|         }
   91|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   36|  43.4k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  43.4k|      {
   88|  43.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  43.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  43.4k|         }
   91|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   118k|      {
   88|   118k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   118k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   118k|         }
   91|   118k|         else {
   92|   118k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   118k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   118k|         }
   94|   118k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.80M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   118k|      {
   88|   118k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   118k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   118k|         }
   91|   118k|         else {
   92|   118k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   118k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   118k|         }
   94|   118k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.75M|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  52.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.5k|      {
   88|  40.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  40.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  40.5k|         }
   91|  40.5k|         else {
   92|  40.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.5k|         }
   94|  40.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.5k|      {
   88|  40.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  40.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  40.5k|         }
   91|  40.5k|         else {
   92|  40.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.5k|         }
   94|  40.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   766k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.3k|      {
   88|  43.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  43.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  43.3k|         }
   91|  43.3k|         else {
   92|  43.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.3k|         }
   94|  43.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.49M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  49.8k|      {
   88|  49.8k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  49.8k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  49.8k|         }
   91|  49.8k|         else {
   92|  49.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  49.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  49.8k|         }
   94|  49.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.55M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   867k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.68M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.65k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.48M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  41.2k|      {
   88|  41.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  41.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  41.2k|         }
   91|  41.2k|         else {
   92|  41.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.2k|         }
   94|  41.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.68M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.64M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  39.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   727k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  38.9k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.83k|      {
   88|  2.83k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.83k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.83k|         }
   91|  2.83k|         else {
   92|  2.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.83k|         }
   94|  2.83k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   948k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   948k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    128|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   727k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   727k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     39|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5applyINS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.80k|      {
   65|  2.80k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.80k|         return Action< Rule >::apply( action_input, st... );
   67|  2.80k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.79k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   40|  43.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS9_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  43.4k|      {
   88|  43.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  43.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  43.4k|         }
   91|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   36|  43.4k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENSA_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  43.4k|      {
   88|  43.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  43.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  43.4k|         }
   91|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  38.5k|      {
   88|  38.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  38.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  38.5k|         }
   91|  38.5k|         else {
   92|  38.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.5k|         }
   94|  38.5k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  38.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.1k|      {
   88|  44.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  44.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  44.1k|         }
   91|  44.1k|         else {
   92|  44.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.1k|         }
   94|  44.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.1k|      {
   88|  44.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  44.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  44.1k|         }
   91|  44.1k|         else {
   92|  44.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.1k|         }
   94|  44.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.1k|      {
   88|  44.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  44.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  44.1k|         }
   91|  44.1k|         else {
   92|  44.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.1k|         }
   94|  44.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.1k|      {
   88|  44.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  44.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  44.1k|         }
   91|  44.1k|         else {
   92|  44.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.1k|         }
   94|  44.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5applyINS3_10id_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.83k|      {
   65|  2.83k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.83k|         return Action< Rule >::apply( action_input, st... );
   67|  2.83k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  41.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   728k|      {
   88|   728k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   728k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   728k|         }
   91|   728k|         else {
   92|   728k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   728k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   728k|         }
   94|   728k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   728k|      {
   88|   728k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   728k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   728k|         }
   91|   728k|         else {
   92|   728k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   728k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   728k|         }
   94|   728k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   737k|      {
   88|   737k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   737k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   737k|         }
   91|   737k|         else {
   92|   737k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   737k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   737k|         }
   94|   737k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.81k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  2.81k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  39.6k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  39.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  39.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.81k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.60k|      {
   88|  2.60k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.60k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.60k|         }
   91|  2.60k|         else {
   92|  2.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.60k|         }
   94|  2.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  36.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.56k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|  2.40k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.40k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.40k|         }
   91|  2.40k|         else {
   92|  2.40k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.40k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.40k|         }
   94|  2.40k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.88k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.20k|      {
   88|  2.20k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.20k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.20k|         }
   91|  2.20k|         else {
   92|  2.20k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.20k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.20k|         }
   94|  2.20k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.56k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.01k|      {
   88|  2.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.01k|         }
   91|  2.01k|         else {
   92|  2.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.01k|         }
   94|  2.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.47k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  25.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.78k|      {
   88|  1.78k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.78k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.78k|         }
   91|  1.78k|         else {
   92|  1.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.78k|         }
   94|  1.78k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  25.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.99k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_10id_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.22k|      {
   65|  1.22k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.22k|         return Action< Rule >::apply( action_input, st... );
   67|  1.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  16.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.3k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  39.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|  2.81k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.81k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.81k|         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  39.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  27.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  12.4k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.48k|      {
   88|  4.48k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.48k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.48k|         }
   91|  4.48k|         else {
   92|  4.48k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.48k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.48k|         }
   94|  4.48k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.27k|      {
   88|  2.27k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.27k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.27k|         }
   91|  2.27k|         else {
   92|  2.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.27k|         }
   94|  2.27k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.27k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.21k|      {
   88|  2.21k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.21k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.21k|         }
   91|  2.21k|         else {
   92|  2.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.21k|         }
   94|  2.21k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   724k|      {
   88|   724k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   724k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   724k|         }
   91|   724k|         else {
   92|   724k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   724k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   724k|         }
   94|   724k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.21k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     56|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.21k|      {
   88|  2.21k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.21k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.21k|         }
   91|  2.21k|         else {
   92|  2.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.21k|         }
   94|  2.21k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  25.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  23.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.65k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.03k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    778|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   725k|      {
   88|   725k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   725k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   725k|         }
   91|   725k|         else {
   92|   725k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   725k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   725k|         }
   94|   725k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   725k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   725k|      {
   88|   725k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   725k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   725k|         }
   91|   725k|         else {
   92|   725k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   725k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   725k|         }
   94|   725k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.45M|      {
   88|  1.45M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.45M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.45M|         }
   91|  1.45M|         else {
   92|  1.45M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.45M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.45M|         }
   94|  1.45M|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.45M|      {
   88|  1.45M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.45M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.45M|         }
   91|  1.45M|         else {
   92|  1.45M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.45M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.45M|         }
   94|  1.45M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.44M|      {
   88|  1.44M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.44M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.44M|         }
   91|  1.44M|         else {
   92|  1.44M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.44M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.44M|         }
   94|  1.44M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   724k|      {
   88|   724k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   724k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   724k|         }
   91|   724k|         else {
   92|   724k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   724k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   724k|         }
   94|   724k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_10id_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   724k|      {
   88|   724k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   724k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   724k|         }
   91|   724k|         else {
   92|   724k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   724k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   724k|         }
   94|   724k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5applyINS3_10id_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   724k|      {
   65|   724k|         const typename ParseInput::action_t action_input( begin, in );
   66|   724k|         return Action< Rule >::apply( action_input, st... );
   67|   724k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   724k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.29k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.38k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    430|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  41.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  41.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.7k|      {
   88|  41.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  41.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  41.7k|         }
   91|  41.7k|         else {
   92|  41.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.7k|         }
   94|  41.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.7k|      {
   88|  41.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  41.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  41.7k|         }
   91|  41.7k|         else {
   92|  41.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.7k|         }
   94|  41.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.7k|      {
   88|  41.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  41.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  41.7k|         }
   91|  41.7k|         else {
   92|  41.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.7k|         }
   94|  41.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5applyINS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.91k|      {
   65|  4.91k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.91k|         return Action< Rule >::apply( action_input, st... );
   67|  4.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.91k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.8k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   488k|      {
   88|   488k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   488k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   488k|         }
   91|   488k|         else {
   92|   488k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   488k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   488k|         }
   94|   488k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   488k|      {
   88|   488k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   488k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   488k|         }
   91|   488k|         else {
   92|   488k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   488k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   488k|         }
   94|   488k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   508k|      {
   88|   508k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   508k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   508k|         }
   91|   508k|         else {
   92|   508k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   508k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   508k|         }
   94|   508k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  26.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.17k|      {
   88|  4.17k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.17k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.17k|         }
   91|  4.17k|         else {
   92|  4.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.17k|         }
   94|  4.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.92k|      {
   88|  3.92k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.92k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.92k|         }
   91|  3.92k|         else {
   92|  3.92k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.92k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.92k|         }
   94|  3.92k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.72k|      {
   88|  3.72k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.72k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.72k|         }
   91|  3.72k|         else {
   92|  3.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.72k|         }
   94|  3.72k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.17k|      {
   88|  3.17k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.17k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.17k|         }
   91|  3.17k|         else {
   92|  3.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.17k|         }
   94|  3.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.72k|      {
   88|  2.72k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.72k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.72k|         }
   91|  2.72k|         else {
   92|  2.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.72k|         }
   94|  2.72k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.37k|      {
   65|  2.37k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.37k|         return Action< Rule >::apply( action_input, st... );
   67|  2.37k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.89k|      {
   88|  4.89k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.89k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.89k|         }
   91|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.59k|      {
   88|  6.59k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.59k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.59k|         }
   91|  6.59k|         else {
   92|  6.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.59k|         }
   94|  6.59k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.32k|      {
   88|  3.32k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.32k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.32k|         }
   91|  3.32k|         else {
   92|  3.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.32k|         }
   94|  3.32k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  17.8k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.27k|      {
   88|  3.27k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.27k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.27k|         }
   91|  3.27k|         else {
   92|  3.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.27k|         }
   94|  3.27k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   481k|      {
   88|   481k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   481k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   481k|         }
   91|   481k|         else {
   92|   481k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   481k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   481k|         }
   94|   481k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  17.3k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    245|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.26k|      {
   88|  3.26k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.26k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.26k|         }
   91|  3.26k|         else {
   92|  3.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.26k|         }
   94|  3.26k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  16.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   484k|      {
   88|   484k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   484k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   484k|         }
   91|   484k|         else {
   92|   484k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   484k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   484k|         }
   94|   484k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   527k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   484k|      {
   88|   484k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   484k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   484k|         }
   91|   484k|         else {
   92|   484k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   484k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   484k|         }
   94|   484k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  54.4M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.04M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  53.3M|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   482k|      {
   88|   482k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   482k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   482k|         }
   91|   482k|         else {
   92|   482k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   482k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   482k|         }
   94|   482k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|   482k|      {
   88|   482k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   482k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   482k|         }
   91|   482k|         else {
   92|   482k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   482k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   482k|         }
   94|   482k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|   519k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.60M|      {
   88|  9.60M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.60M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.60M|         }
   91|  9.60M|         else {
   92|  9.60M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.60M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.60M|         }
   94|  9.60M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.12M|      {
   88|  9.12M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.12M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.12M|         }
   91|  9.12M|         else {
   92|  9.12M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.12M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.12M|         }
   94|  9.12M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  53.3M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.12M|      {
   88|  9.12M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.12M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.12M|         }
   91|  9.12M|         else {
   92|  9.12M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.12M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.12M|         }
   94|  9.12M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  53.3M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.12M|      {
   88|  9.12M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.12M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.12M|         }
   91|  9.12M|         else {
   92|  9.12M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.12M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.12M|         }
   94|  9.12M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  77.2M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.07M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  76.1M|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|   165k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   165k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   165k|         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|   165k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   165k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   165k|         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   916k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|   165k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   165k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   165k|         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.07M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|   165k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   165k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   165k|         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.07M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   287k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   784k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  47.9k|      {
   88|  47.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.9k|         }
   91|  47.9k|         else {
   92|  47.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.9k|         }
   94|  47.9k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  47.9k|      {
   88|  47.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.9k|         }
   91|  47.9k|         else {
   92|  47.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.9k|         }
   94|  47.9k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   287k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  95.8k|      {
   88|  95.8k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  95.8k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  95.8k|         }
   91|  95.8k|         else {
   92|  95.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  95.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  95.8k|         }
   94|  95.8k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   286k|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    356|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|    356|      {
   49|    356|#if defined( __cpp_exceptions )
   50|    356|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|    356|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   286k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   784k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   117k|      {
   88|   117k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   117k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   117k|         }
   91|   117k|         else {
   92|   117k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   117k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   117k|         }
   94|   117k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   784k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   193k|      {
   88|   193k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   193k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   193k|         }
   91|   193k|         else {
   92|   193k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   193k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   193k|         }
   94|   193k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.20M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   483k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   717k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  50.4k|      {
   88|  50.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  50.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  50.4k|         }
   91|  50.4k|         else {
   92|  50.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.4k|         }
   94|  50.4k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  50.4k|      {
   88|  50.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  50.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  50.4k|         }
   91|  50.4k|         else {
   92|  50.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.4k|         }
   94|  50.4k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   294k|      {}
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   294k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   294k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   489k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  67.5k|      {
   88|  67.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  67.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  67.5k|         }
   91|  67.5k|         else {
   92|  67.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  67.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  67.5k|         }
   94|  67.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   489k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   479k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.85k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    751|      {
   88|    751|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|    751|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|    751|         }
   91|    751|         else {
   92|    751|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    751|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    751|         }
   94|    751|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   915k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    385|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|    385|      {
   49|    385|#if defined( __cpp_exceptions )
   50|    385|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|    385|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   915k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  52.4M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12name_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.95M|      {
   88|  8.95M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  8.95M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  8.95M|         }
   91|  8.95M|         else {
   92|  8.95M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.95M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.95M|         }
   94|  8.95M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  76.1M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  76.1M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.61k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  53.3M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.33k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|   517k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|  1.33k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|  1.33k|      {
   49|  1.33k|#if defined( __cpp_exceptions )
   50|  1.33k|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|  1.33k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   482k|      {
   65|   482k|         const typename ParseInput::action_t action_input( begin, in );
   66|   482k|         return Action< Rule >::apply( action_input, st... );
   67|   482k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   517k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.52k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  22.0k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  2.02k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.20k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.20k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.1k|      {
   88|  37.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  37.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  37.1k|         }
   91|  37.1k|         else {
   92|  37.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.1k|         }
   94|  37.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.1k|      {
   88|  37.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  37.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  37.1k|         }
   91|  37.1k|         else {
   92|  37.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.1k|         }
   94|  37.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.1k|      {
   88|  37.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  37.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  37.1k|         }
   91|  37.1k|         else {
   92|  37.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.1k|         }
   94|  37.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5applyINS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.55k|      {
   65|  4.55k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.55k|         return Action< Rule >::apply( action_input, st... );
   67|  4.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.55k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  32.6k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  15.6k|      {
   88|  15.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  15.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  15.6k|         }
   91|  15.6k|         else {
   92|  15.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6k|         }
   94|  15.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.6k|      {
   88|  15.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  15.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  15.6k|         }
   91|  15.6k|         else {
   92|  15.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6k|         }
   94|  15.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  24.0k|      {
   88|  24.0k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  24.0k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  24.0k|         }
   91|  24.0k|         else {
   92|  24.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.0k|         }
   94|  24.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.16k|      {
   88|  4.16k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.16k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.16k|         }
   91|  4.16k|         else {
   92|  4.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.16k|         }
   94|  4.16k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.93k|      {
   88|  3.93k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.93k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.93k|         }
   91|  3.93k|         else {
   92|  3.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.93k|         }
   94|  3.93k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.37k|      {
   88|  3.37k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.37k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.37k|         }
   91|  3.37k|         else {
   92|  3.37k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.37k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.37k|         }
   94|  3.37k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.16k|      {
   88|  3.16k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.16k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.16k|         }
   91|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.67k|      {
   88|  2.67k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.67k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.67k|         }
   91|  2.67k|         else {
   92|  2.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.67k|         }
   94|  2.67k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.07k|      {
   65|  2.07k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.07k|         return Action< Rule >::apply( action_input, st... );
   67|  2.07k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.53k|      {
   88|  4.53k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.53k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.53k|         }
   91|  4.53k|         else {
   92|  4.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.53k|         }
   94|  4.53k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.41k|      {
   88|  3.41k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.41k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.41k|         }
   91|  3.41k|         else {
   92|  3.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.41k|         }
   94|  3.41k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.36k|      {
   88|  3.36k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.36k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.36k|         }
   91|  3.36k|         else {
   92|  3.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.36k|         }
   94|  3.36k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.99k|      {
   88|  8.99k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  8.99k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  8.99k|         }
   91|  8.99k|         else {
   92|  8.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.99k|         }
   94|  8.99k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.35k|      {
   88|  3.35k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.35k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.35k|         }
   91|  3.35k|         else {
   92|  3.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.35k|         }
   94|  3.35k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.1k|      {
   88|  11.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  11.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  11.1k|         }
   91|  11.1k|         else {
   92|  11.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.1k|         }
   94|  11.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  11.1k|      {
   88|  11.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  11.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  11.1k|         }
   91|  11.1k|         else {
   92|  11.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.1k|         }
   94|  11.1k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.98k|      {
   88|  9.98k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.98k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.98k|         }
   91|  9.98k|         else {
   92|  9.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.98k|         }
   94|  9.98k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  9.98k|      {
   88|  9.98k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.98k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.98k|         }
   91|  9.98k|         else {
   92|  9.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.98k|         }
   94|  9.98k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.71M|      {
   88|  9.71M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.71M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.71M|         }
   91|  9.71M|         else {
   92|  9.71M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.71M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.71M|         }
   94|  9.71M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.70M|      {
   88|  9.70M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.70M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.70M|         }
   91|  9.70M|         else {
   92|  9.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.70M|         }
   94|  9.70M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.70M|      {
   88|  9.70M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.70M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.70M|         }
   91|  9.70M|         else {
   92|  9.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.70M|         }
   94|  9.70M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.70M|      {
   88|  9.70M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.70M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.70M|         }
   91|  9.70M|         else {
   92|  9.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.70M|         }
   94|  9.70M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   107k|      {
   88|   107k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   107k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   107k|         }
   91|   107k|         else {
   92|   107k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   107k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   107k|         }
   94|   107k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   107k|      {
   88|   107k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   107k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   107k|         }
   91|   107k|         else {
   92|   107k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   107k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   107k|         }
   94|   107k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   107k|      {
   88|   107k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   107k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   107k|         }
   91|   107k|         else {
   92|   107k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   107k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   107k|         }
   94|   107k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   107k|      {
   88|   107k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   107k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   107k|         }
   91|   107k|         else {
   92|   107k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   107k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   107k|         }
   94|   107k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  39.3k|      {
   88|  39.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  39.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  39.3k|         }
   91|  39.3k|         else {
   92|  39.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.3k|         }
   94|  39.3k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  39.3k|      {
   88|  39.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  39.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  39.3k|         }
   91|  39.3k|         else {
   92|  39.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.3k|         }
   94|  39.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  78.6k|      {
   88|  78.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  78.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  78.6k|         }
   91|  78.6k|         else {
   92|  78.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  78.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  78.6k|         }
   94|  78.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  67.9k|      {
   88|  67.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  67.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  67.9k|         }
   91|  67.9k|         else {
   92|  67.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  67.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  67.9k|         }
   94|  67.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  99.9k|      {
   88|  99.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  99.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  99.9k|         }
   91|  99.9k|         else {
   92|  99.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  99.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  99.9k|         }
   94|  99.9k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  23.2k|      {
   88|  23.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.2k|         }
   91|  23.2k|         else {
   92|  23.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.2k|         }
   94|  23.2k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  23.2k|      {
   88|  23.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.2k|         }
   91|  23.2k|         else {
   92|  23.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.2k|         }
   94|  23.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.7k|      {
   88|  44.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  44.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  44.7k|         }
   91|  44.7k|         else {
   92|  44.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7k|         }
   94|  44.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.03k|      {
   88|  1.03k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.03k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.03k|         }
   91|  1.03k|         else {
   92|  1.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.03k|         }
   94|  1.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_12hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.59M|      {
   88|  9.59M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.59M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.59M|         }
   91|  9.59M|         else {
   92|  9.59M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.59M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.59M|         }
   94|  9.59M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  9.68k|      {
   65|  9.68k|         const typename ParseInput::action_t action_input( begin, in );
   66|  9.68k|         return Action< Rule >::apply( action_input, st... );
   67|  9.68k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  32.9k|      {
   88|  32.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  32.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  32.9k|         }
   91|  32.9k|         else {
   92|  32.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.9k|         }
   94|  32.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  32.9k|      {
   88|  32.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  32.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  32.9k|         }
   91|  32.9k|         else {
   92|  32.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.9k|         }
   94|  32.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  32.9k|      {
   88|  32.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  32.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  32.9k|         }
   91|  32.9k|         else {
   92|  32.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.9k|         }
   94|  32.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5applyINS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.05k|      {
   65|  3.05k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.05k|         return Action< Rule >::apply( action_input, st... );
   67|  3.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.05k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  29.8k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.44k|      {
   88|  9.44k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.44k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.44k|         }
   91|  9.44k|         else {
   92|  9.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.44k|         }
   94|  9.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.44k|      {
   88|  9.44k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.44k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.44k|         }
   91|  9.44k|         else {
   92|  9.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.44k|         }
   94|  9.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  17.9k|      {
   88|  17.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  17.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  17.9k|         }
   91|  17.9k|         else {
   92|  17.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.9k|         }
   94|  17.9k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.77k|      {
   88|  2.77k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.77k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.77k|         }
   91|  2.77k|         else {
   92|  2.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.77k|         }
   94|  2.77k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.56k|      {
   88|  2.56k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.56k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.56k|         }
   91|  2.56k|         else {
   92|  2.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.56k|         }
   94|  2.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.11k|      {
   88|  2.11k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.11k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.11k|         }
   91|  2.11k|         else {
   92|  2.11k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.11k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.11k|         }
   94|  2.11k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.04k|      {
   88|  2.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.04k|         }
   91|  2.04k|         else {
   92|  2.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.04k|         }
   94|  2.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.79k|      {
   88|  1.79k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.79k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.79k|         }
   91|  1.79k|         else {
   92|  1.79k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.79k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.79k|         }
   94|  1.79k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.44k|      {
   65|  1.44k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.44k|         return Action< Rule >::apply( action_input, st... );
   67|  1.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.04k|      {
   88|  3.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.04k|         }
   91|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.43k|      {
   88|  4.43k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.43k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.43k|         }
   91|  4.43k|         else {
   92|  4.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.43k|         }
   94|  4.43k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.25k|      {
   88|  2.25k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.25k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.25k|         }
   91|  2.25k|         else {
   92|  2.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.25k|         }
   94|  2.25k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.19k|      {
   88|  2.19k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.19k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.19k|         }
   91|  2.19k|         else {
   92|  2.19k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.19k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.19k|         }
   94|  2.19k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.94k|      {
   88|  4.94k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.94k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.94k|         }
   91|  4.94k|         else {
   92|  4.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.94k|         }
   94|  4.94k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.18k|      {
   88|  2.18k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.18k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.18k|         }
   91|  2.18k|         else {
   92|  2.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.18k|         }
   94|  2.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.33k|      {
   88|  6.33k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.33k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.33k|         }
   91|  6.33k|         else {
   92|  6.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.33k|         }
   94|  6.33k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.33k|      {
   88|  6.33k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.33k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.33k|         }
   91|  6.33k|         else {
   92|  6.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.33k|         }
   94|  6.33k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.65k|      {
   88|  5.65k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.65k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.65k|         }
   91|  5.65k|         else {
   92|  5.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.65k|         }
   94|  5.65k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.65k|      {
   88|  5.65k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.65k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.65k|         }
   91|  5.65k|         else {
   92|  5.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.65k|         }
   94|  5.65k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.30M|      {
   88|  6.30M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.30M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.30M|         }
   91|  6.30M|         else {
   92|  6.30M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.30M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.30M|         }
   94|  6.30M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.29M|      {
   88|  6.29M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.29M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.29M|         }
   91|  6.29M|         else {
   92|  6.29M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.29M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.29M|         }
   94|  6.29M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.29M|      {
   88|  6.29M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.29M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.29M|         }
   91|  6.29M|         else {
   92|  6.29M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.29M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.29M|         }
   94|  6.29M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.29M|      {
   88|  6.29M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.29M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.29M|         }
   91|  6.29M|         else {
   92|  6.29M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.29M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.29M|         }
   94|  6.29M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|  97.4k|      {
   88|  97.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  97.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  97.4k|         }
   91|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  97.4k|      {
   88|  97.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  97.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  97.4k|         }
   91|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  97.4k|      {
   88|  97.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  97.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  97.4k|         }
   91|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  97.4k|      {
   88|  97.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  97.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  97.4k|         }
   91|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  41.5k|      {
   88|  41.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  41.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  41.5k|         }
   91|  41.5k|         else {
   92|  41.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.5k|         }
   94|  41.5k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  41.5k|      {
   88|  41.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  41.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  41.5k|         }
   91|  41.5k|         else {
   92|  41.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.5k|         }
   94|  41.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  82.9k|      {
   88|  82.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  82.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  82.9k|         }
   91|  82.9k|         else {
   92|  82.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  82.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  82.9k|         }
   94|  82.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  55.9k|      {
   88|  55.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  55.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  55.9k|         }
   91|  55.9k|         else {
   92|  55.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  55.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  55.9k|         }
   94|  55.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  87.1k|      {
   88|  87.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  87.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  87.1k|         }
   91|  87.1k|         else {
   92|  87.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  87.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  87.1k|         }
   94|  87.1k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  19.5k|      {
   88|  19.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  19.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  19.5k|         }
   91|  19.5k|         else {
   92|  19.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.5k|         }
   94|  19.5k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  19.5k|      {
   88|  19.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  19.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  19.5k|         }
   91|  19.5k|         else {
   92|  19.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.5k|         }
   94|  19.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  36.4k|      {
   88|  36.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  36.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  36.4k|         }
   91|  36.4k|         else {
   92|  36.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.4k|         }
   94|  36.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    926|      {
   88|    926|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|    926|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|    926|         }
   91|    926|         else {
   92|    926|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    926|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    926|         }
   94|    926|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_19parent_hash_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.20M|      {
   88|  6.20M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.20M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.20M|         }
   91|  6.20M|         else {
   92|  6.20M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.20M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.20M|         }
   94|  6.20M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.40k|      {
   65|  5.40k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.40k|         return Action< Rule >::apply( action_input, st... );
   67|  5.40k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  30.1k|      {
   88|  30.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.1k|         }
   91|  30.1k|         else {
   92|  30.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.1k|         }
   94|  30.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  30.1k|      {
   88|  30.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.1k|         }
   91|  30.1k|         else {
   92|  30.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.1k|         }
   94|  30.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  30.1k|      {
   88|  30.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.1k|         }
   91|  30.1k|         else {
   92|  30.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.1k|         }
   94|  30.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5applyINS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.03k|      {
   65|  3.03k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.03k|         return Action< Rule >::apply( action_input, st... );
   67|  3.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.03k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.1k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  7.49k|      {
   88|  7.49k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.49k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.49k|         }
   91|  7.49k|         else {
   92|  7.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.49k|         }
   94|  7.49k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  7.49k|      {
   88|  7.49k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.49k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.49k|         }
   91|  7.49k|         else {
   92|  7.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.49k|         }
   94|  7.49k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  13.4k|      {
   88|  13.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  13.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  13.4k|         }
   91|  13.4k|         else {
   92|  13.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.4k|         }
   94|  13.4k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.94k|      {
   88|  2.94k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.94k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.94k|         }
   91|  2.94k|         else {
   92|  2.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.94k|         }
   94|  2.94k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.65k|      {
   88|  2.65k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.65k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.65k|         }
   91|  2.65k|         else {
   92|  2.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.65k|         }
   94|  2.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.45k|      {
   88|  2.45k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.45k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.45k|         }
   91|  2.45k|         else {
   92|  2.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.45k|         }
   94|  2.45k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.17k|      {
   88|  2.17k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.17k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.17k|         }
   91|  2.17k|         else {
   92|  2.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.17k|         }
   94|  2.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.04k|      {
   88|  2.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.04k|         }
   91|  2.04k|         else {
   92|  2.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.04k|         }
   94|  2.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.00k|      {
   65|  1.00k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.00k|         return Action< Rule >::apply( action_input, st... );
   67|  1.00k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|  3.01k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.01k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.01k|         }
   91|  3.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.39k|      {
   88|  3.39k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.39k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.39k|         }
   91|  3.39k|         else {
   92|  3.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.39k|         }
   94|  3.39k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  1.72k|      {
   88|  1.72k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.72k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.72k|         }
   91|  1.72k|         else {
   92|  1.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.72k|         }
   94|  1.72k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.67k|      {
   88|  1.67k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.67k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.67k|         }
   91|  1.67k|         else {
   92|  1.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.67k|         }
   94|  1.67k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.45k|      {
   88|  3.45k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.45k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.45k|         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.66k|      {
   88|  1.66k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.66k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.66k|         }
   91|  1.66k|         else {
   92|  1.66k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.66k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.66k|         }
   94|  1.66k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.59k|      {
   88|  5.59k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.59k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.59k|         }
   91|  5.59k|         else {
   92|  5.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.59k|         }
   94|  5.59k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.59k|      {
   88|  5.59k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.59k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.59k|         }
   91|  5.59k|         else {
   92|  5.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.59k|         }
   94|  5.59k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.64k|      {
   88|  4.64k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.64k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.64k|         }
   91|  4.64k|         else {
   92|  4.64k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.64k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.64k|         }
   94|  4.64k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  4.64k|      {
   88|  4.64k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.64k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.64k|         }
   91|  4.64k|         else {
   92|  4.64k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.64k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.64k|         }
   94|  4.64k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.35M|      {
   88|  7.35M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.35M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.35M|         }
   91|  7.35M|         else {
   92|  7.35M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.35M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.35M|         }
   94|  7.35M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|  7.34M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.34M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.34M|         }
   91|  7.34M|         else {
   92|  7.34M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.34M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.34M|         }
   94|  7.34M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|  7.34M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.34M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.34M|         }
   91|  7.34M|         else {
   92|  7.34M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.34M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.34M|         }
   94|  7.34M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|  7.34M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.34M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.34M|         }
   91|  7.34M|         else {
   92|  7.34M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.34M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.34M|         }
   94|  7.34M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   151k|      {
   88|   151k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   151k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   151k|         }
   91|   151k|         else {
   92|   151k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   151k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   151k|         }
   94|   151k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   151k|      {
   88|   151k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   151k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   151k|         }
   91|   151k|         else {
   92|   151k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   151k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   151k|         }
   94|   151k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   151k|      {
   88|   151k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   151k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   151k|         }
   91|   151k|         else {
   92|   151k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   151k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   151k|         }
   94|   151k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   151k|      {
   88|   151k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   151k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   151k|         }
   91|   151k|         else {
   92|   151k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   151k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   151k|         }
   94|   151k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  37.9k|      {
   88|  37.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  37.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  37.9k|         }
   91|  37.9k|         else {
   92|  37.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.9k|         }
   94|  37.9k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  37.9k|      {
   88|  37.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  37.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  37.9k|         }
   91|  37.9k|         else {
   92|  37.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.9k|         }
   94|  37.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  75.9k|      {
   88|  75.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  75.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  75.9k|         }
   91|  75.9k|         else {
   92|  75.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.9k|         }
   94|  75.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   113k|      {
   88|   113k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   113k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   113k|         }
   91|   113k|         else {
   92|   113k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   113k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   113k|         }
   94|   113k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   173k|      {
   88|   173k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   173k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   173k|         }
   91|   173k|         else {
   92|   173k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   173k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   173k|         }
   94|   173k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  42.2k|      {
   88|  42.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  42.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  42.2k|         }
   91|  42.2k|         else {
   92|  42.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.2k|         }
   94|  42.2k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  42.2k|      {
   88|  42.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  42.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  42.2k|         }
   91|  42.2k|         else {
   92|  42.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.2k|         }
   94|  42.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  70.8k|      {
   88|  70.8k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  70.8k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  70.8k|         }
   91|  70.8k|         else {
   92|  70.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.8k|         }
   94|  70.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.99k|      {
   88|  1.99k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.99k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.99k|         }
   91|  1.99k|         else {
   92|  1.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.99k|         }
   94|  1.99k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_14serial_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.19M|      {
   88|  7.19M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.19M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.19M|         }
   91|  7.19M|         else {
   92|  7.19M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.19M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.19M|         }
   94|  7.19M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.36k|      {
   65|  4.36k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.36k|         return Action< Rule >::apply( action_input, st... );
   67|  4.36k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  27.4k|      {
   88|  27.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  27.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  27.4k|         }
   91|  27.4k|         else {
   92|  27.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.4k|         }
   94|  27.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  27.4k|      {
   88|  27.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  27.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  27.4k|         }
   91|  27.4k|         else {
   92|  27.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.4k|         }
   94|  27.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  27.4k|      {
   88|  27.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  27.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  27.4k|         }
   91|  27.4k|         else {
   92|  27.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.4k|         }
   94|  27.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5applyINS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.16k|      {
   65|  3.16k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.16k|         return Action< Rule >::apply( action_input, st... );
   67|  3.16k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.29k|      {
   88|  8.29k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  8.29k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  8.29k|         }
   91|  8.29k|         else {
   92|  8.29k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.29k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.29k|         }
   94|  8.29k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.29k|      {
   88|  8.29k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  8.29k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  8.29k|         }
   91|  8.29k|         else {
   92|  8.29k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.29k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.29k|         }
   94|  8.29k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.4k|      {
   88|  15.4k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  15.4k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  15.4k|         }
   91|  15.4k|         else {
   92|  15.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.4k|         }
   94|  15.4k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.95k|      {
   88|  2.95k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.95k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.95k|         }
   91|  2.95k|         else {
   92|  2.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.95k|         }
   94|  2.95k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.73k|      {
   88|  2.73k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.73k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.73k|         }
   91|  2.73k|         else {
   92|  2.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.73k|         }
   94|  2.73k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.52k|      {
   88|  2.52k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.52k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.52k|         }
   91|  2.52k|         else {
   92|  2.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.52k|         }
   94|  2.52k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.33k|      {
   88|  2.33k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.33k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.33k|         }
   91|  2.33k|         else {
   92|  2.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.33k|         }
   94|  2.33k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.99k|      {
   88|  1.99k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.99k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.99k|         }
   91|  1.99k|         else {
   92|  1.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.99k|         }
   94|  1.99k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.36k|      {
   65|  1.36k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.36k|         return Action< Rule >::apply( action_input, st... );
   67|  1.36k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.15k|      {
   88|  3.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.15k|         }
   91|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.02k|      {
   88|  4.02k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.02k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.02k|         }
   91|  4.02k|         else {
   92|  4.02k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.02k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.02k|         }
   94|  4.02k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.04k|      {
   88|  2.04k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.04k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.04k|         }
   91|  2.04k|         else {
   92|  2.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.04k|         }
   94|  2.04k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.98k|      {
   88|  1.98k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.98k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.98k|         }
   91|  1.98k|         else {
   92|  1.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.98k|         }
   94|  1.98k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.76k|      {
   88|  3.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.76k|         }
   91|  3.76k|         else {
   92|  3.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.76k|         }
   94|  3.76k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.98k|      {
   88|  1.98k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.98k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.98k|         }
   91|  1.98k|         else {
   92|  1.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.98k|         }
   94|  1.98k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.71k|      {
   88|  5.71k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.71k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.71k|         }
   91|  5.71k|         else {
   92|  5.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.71k|         }
   94|  5.71k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.71k|      {
   88|  5.71k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.71k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.71k|         }
   91|  5.71k|         else {
   92|  5.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.71k|         }
   94|  5.71k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.75k|      {
   88|  4.75k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.75k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.75k|         }
   91|  4.75k|         else {
   92|  4.75k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.75k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.75k|         }
   94|  4.75k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  4.75k|      {
   88|  4.75k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.75k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.75k|         }
   91|  4.75k|         else {
   92|  4.75k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.75k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.75k|         }
   94|  4.75k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.87M|      {
   88|  7.87M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.87M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.87M|         }
   91|  7.87M|         else {
   92|  7.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.87M|         }
   94|  7.87M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.87M|      {
   88|  7.87M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.87M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.87M|         }
   91|  7.87M|         else {
   92|  7.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.87M|         }
   94|  7.87M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.87M|      {
   88|  7.87M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.87M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.87M|         }
   91|  7.87M|         else {
   92|  7.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.87M|         }
   94|  7.87M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.87M|      {
   88|  7.87M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.87M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.87M|         }
   91|  7.87M|         else {
   92|  7.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.87M|         }
   94|  7.87M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|   156k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   156k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   156k|         }
   91|   156k|         else {
   92|   156k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   156k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   156k|         }
   94|   156k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|   156k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   156k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   156k|         }
   91|   156k|         else {
   92|   156k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   156k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   156k|         }
   94|   156k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|   156k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   156k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   156k|         }
   91|   156k|         else {
   92|   156k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   156k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   156k|         }
   94|   156k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|   156k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   156k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   156k|         }
   91|   156k|         else {
   92|   156k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   156k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   156k|         }
   94|   156k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  28.6k|      {
   88|  28.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  28.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  28.6k|         }
   91|  28.6k|         else {
   92|  28.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.6k|         }
   94|  28.6k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  28.6k|      {
   88|  28.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  28.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  28.6k|         }
   91|  28.6k|         else {
   92|  28.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.6k|         }
   94|  28.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  57.2k|      {
   88|  57.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  57.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  57.2k|         }
   91|  57.2k|         else {
   92|  57.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  57.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  57.2k|         }
   94|  57.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   128k|      {
   88|   128k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   128k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   128k|         }
   91|   128k|         else {
   92|   128k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   128k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   128k|         }
   94|   128k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   192k|      {
   88|   192k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   192k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   192k|         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  47.2k|      {
   88|  47.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.2k|         }
   91|  47.2k|         else {
   92|  47.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.2k|         }
   94|  47.2k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  47.2k|      {
   88|  47.2k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  47.2k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  47.2k|         }
   91|  47.2k|         else {
   92|  47.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.2k|         }
   94|  47.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  80.8k|      {
   88|  80.8k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  80.8k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  80.8k|         }
   91|  80.8k|         else {
   92|  80.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  80.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  80.8k|         }
   94|  80.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.70k|      {
   88|  1.70k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.70k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.70k|         }
   91|  1.70k|         else {
   92|  1.70k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.70k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.70k|         }
   94|  1.70k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_16via_port_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.71M|      {
   88|  7.71M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.71M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.71M|         }
   91|  7.71M|         else {
   92|  7.71M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.71M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.71M|         }
   94|  7.71M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.45k|      {
   65|  4.45k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.45k|         return Action< Rule >::apply( action_input, st... );
   67|  4.45k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  24.5k|      {
   88|  24.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  24.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  24.5k|         }
   91|  24.5k|         else {
   92|  24.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.5k|         }
   94|  24.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  24.5k|      {
   88|  24.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  24.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  24.5k|         }
   91|  24.5k|         else {
   92|  24.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.5k|         }
   94|  24.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  24.5k|      {
   88|  24.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  24.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  24.5k|         }
   91|  24.5k|         else {
   92|  24.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.5k|         }
   94|  24.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5applyINS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.60k|      {
   65|  3.60k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.60k|         return Action< Rule >::apply( action_input, st... );
   67|  3.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.60k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  20.9k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   115k|      {
   88|   115k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   115k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   115k|         }
   91|   115k|         else {
   92|   115k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   115k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   115k|         }
   94|   115k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   115k|      {
   88|   115k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   115k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   115k|         }
   91|   115k|         else {
   92|   115k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   115k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   115k|         }
   94|   115k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   130k|      {
   88|   130k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   130k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   130k|         }
   91|   130k|         else {
   92|   130k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   130k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   130k|         }
   94|   130k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.58k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.58k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.51k|      {
   88|  3.51k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.51k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.51k|         }
   91|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.23k|      {
   88|  3.23k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.23k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.23k|         }
   91|  3.23k|         else {
   92|  3.23k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.23k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.23k|         }
   94|  3.23k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.93k|      {
   88|  2.93k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.93k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.93k|         }
   91|  2.93k|         else {
   92|  2.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.93k|         }
   94|  2.93k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.56k|      {
   88|  2.56k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.56k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.56k|         }
   91|  2.56k|         else {
   92|  2.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.56k|         }
   94|  2.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.05k|      {
   88|  2.05k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.05k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.05k|         }
   91|  2.05k|         else {
   92|  2.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.05k|         }
   94|  2.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.86k|      {
   65|  1.86k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.86k|         return Action< Rule >::apply( action_input, st... );
   67|  1.86k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|  3.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.58k|         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.18k|      {
   88|  5.18k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.18k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.18k|         }
   91|  5.18k|         else {
   92|  5.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.18k|         }
   94|  5.18k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.62k|      {
   88|  2.62k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.62k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.62k|         }
   91|  2.62k|         else {
   92|  2.62k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.62k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.62k|         }
   94|  2.62k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.62k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.56k|      {
   88|  2.56k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.56k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.56k|         }
   91|  2.56k|         else {
   92|  2.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.56k|         }
   94|  2.56k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   109k|      {
   88|   109k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   109k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   109k|         }
   91|   109k|         else {
   92|   109k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   109k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   109k|         }
   94|   109k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.56k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     59|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.56k|      {
   88|  2.56k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.56k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.56k|         }
   91|  2.56k|         else {
   92|  2.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.56k|         }
   94|  2.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.40k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.18k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   111k|      {
   88|   111k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   111k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   111k|         }
   91|   111k|         else {
   92|   111k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   111k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   111k|         }
   94|   111k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   111k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   111k|      {
   88|   111k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   111k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   111k|         }
   91|   111k|         else {
   92|   111k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   111k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   111k|         }
   94|   111k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   333k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   472k|      {
   88|   472k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   472k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   472k|         }
   91|   472k|         else {
   92|   472k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   472k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   472k|         }
   94|   472k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   139k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   193k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   221k|      {
   88|   221k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   221k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   221k|         }
   91|   221k|         else {
   92|   221k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   221k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   221k|         }
   94|   221k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   221k|      {
   88|   221k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   221k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   221k|         }
   91|   221k|         else {
   92|   221k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   221k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   221k|         }
   94|   221k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   221k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   221k|      {
   88|   221k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   221k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   221k|         }
   91|   221k|         else {
   92|   221k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   221k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   221k|         }
   94|   221k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser22with_interface_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   192k|      {
   88|   192k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   192k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   192k|         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   221k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     51|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5applyINS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   110k|      {
   65|   110k|         const typename ParseInput::action_t action_input( begin, in );
   66|   110k|         return Action< Rule >::apply( action_input, st... );
   67|   110k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   110k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.45k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.16k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    415|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  21.3k|      {
   88|  21.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  21.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  21.3k|         }
   91|  21.3k|         else {
   92|  21.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.3k|         }
   94|  21.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  21.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  21.3k|      {
   88|  21.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  21.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  21.3k|         }
   91|  21.3k|         else {
   92|  21.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.3k|         }
   94|  21.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  21.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  21.3k|      {
   88|  21.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  21.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  21.3k|         }
   91|  21.3k|         else {
   92|  21.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.3k|         }
   94|  21.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  21.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5applyINS3_25with_connect_type_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.52k|      {
   65|  3.52k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.52k|         return Action< Rule >::apply( action_input, st... );
   67|  3.52k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.51k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  17.8k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.44k|      {
   88|  9.44k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.44k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.44k|         }
   91|  9.44k|         else {
   92|  9.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.44k|         }
   94|  9.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.44k|      {
   88|  9.44k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  9.44k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  9.44k|         }
   91|  9.44k|         else {
   92|  9.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.44k|         }
   94|  9.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  19.0k|      {
   88|  19.0k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  19.0k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  19.0k|         }
   91|  19.0k|         else {
   92|  19.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.0k|         }
   94|  19.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.14k|      {
   88|  3.14k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.14k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.14k|         }
   91|  3.14k|         else {
   92|  3.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.14k|         }
   94|  3.14k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.91k|      {
   88|  2.91k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.91k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.91k|         }
   91|  2.91k|         else {
   92|  2.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.91k|         }
   94|  2.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.58k|      {
   88|  2.58k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.58k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.58k|         }
   91|  2.58k|         else {
   92|  2.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.58k|         }
   94|  2.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.39k|      {
   88|  2.39k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.39k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.39k|         }
   91|  2.39k|         else {
   92|  2.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.39k|         }
   94|  2.39k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.26k|      {
   88|  2.26k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.26k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.26k|         }
   91|  2.26k|         else {
   92|  2.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.26k|         }
   94|  2.26k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_25with_connect_type_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.44k|      {
   65|  1.44k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.44k|         return Action< Rule >::apply( action_input, st... );
   67|  1.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.50k|      {
   88|  3.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.50k|         }
   91|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.43k|      {
   88|  5.43k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.43k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.43k|         }
   91|  5.43k|         else {
   92|  5.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.43k|         }
   94|  5.43k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.74k|      {
   88|  2.74k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.74k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.74k|         }
   91|  2.74k|         else {
   92|  2.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.74k|         }
   94|  2.74k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.70k|      {
   88|  2.70k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.70k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.70k|         }
   91|  2.70k|         else {
   92|  2.70k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.70k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.70k|         }
   94|  2.70k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.48k|      {
   88|  4.48k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.48k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.48k|         }
   91|  4.48k|         else {
   92|  4.48k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.48k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.48k|         }
   94|  4.48k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.69k|      {
   88|  2.69k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.69k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.69k|         }
   91|  2.69k|         else {
   92|  2.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.69k|         }
   94|  2.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.52k|      {
   88|  6.52k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.52k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.52k|         }
   91|  6.52k|         else {
   92|  6.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.52k|         }
   94|  6.52k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.52k|      {
   88|  6.52k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.52k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.52k|         }
   91|  6.52k|         else {
   92|  6.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.52k|         }
   94|  6.52k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.15k|      {
   88|  5.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.15k|         }
   91|  5.15k|         else {
   92|  5.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.15k|         }
   94|  5.15k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.15k|      {
   88|  5.15k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.15k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.15k|         }
   91|  5.15k|         else {
   92|  5.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.15k|         }
   94|  5.15k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.66M|      {
   88|  5.66M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.66M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.66M|         }
   91|  5.66M|         else {
   92|  5.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.66M|         }
   94|  5.66M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.66M|      {
   88|  5.66M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.66M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.66M|         }
   91|  5.66M|         else {
   92|  5.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.66M|         }
   94|  5.66M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.66M|      {
   88|  5.66M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.66M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.66M|         }
   91|  5.66M|         else {
   92|  5.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.66M|         }
   94|  5.66M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.66M|      {
   88|  5.66M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.66M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.66M|         }
   91|  5.66M|         else {
   92|  5.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.66M|         }
   94|  5.66M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|   116k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   116k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   116k|         }
   91|   116k|         else {
   92|   116k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   116k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   116k|         }
   94|   116k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|   116k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   116k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   116k|         }
   91|   116k|         else {
   92|   116k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   116k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   116k|         }
   94|   116k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|   116k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   116k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   116k|         }
   91|   116k|         else {
   92|   116k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   116k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   116k|         }
   94|   116k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|   116k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   116k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   116k|         }
   91|   116k|         else {
   92|   116k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   116k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   116k|         }
   94|   116k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  30.9k|      {
   88|  30.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.9k|         }
   91|  30.9k|         else {
   92|  30.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.9k|         }
   94|  30.9k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  30.9k|      {
   88|  30.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.9k|         }
   91|  30.9k|         else {
   92|  30.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.9k|         }
   94|  30.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  61.8k|      {
   88|  61.8k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  61.8k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  61.8k|         }
   91|  61.8k|         else {
   92|  61.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  61.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  61.8k|         }
   94|  61.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  85.8k|      {
   88|  85.8k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  85.8k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  85.8k|         }
   91|  85.8k|         else {
   92|  85.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.8k|         }
   94|  85.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   138k|      {
   88|   138k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   138k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   138k|         }
   91|   138k|         else {
   92|   138k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   138k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   138k|         }
   94|   138k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  33.7k|      {
   88|  33.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  33.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  33.7k|         }
   91|  33.7k|         else {
   92|  33.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.7k|         }
   94|  33.7k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  33.7k|      {
   88|  33.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  33.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  33.7k|         }
   91|  33.7k|         else {
   92|  33.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.7k|         }
   94|  33.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  52.1k|      {
   88|  52.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  52.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  52.1k|         }
   91|  52.1k|         else {
   92|  52.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  52.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  52.1k|         }
   94|  52.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.25k|      {
   88|  1.25k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.25k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.25k|         }
   91|  1.25k|         else {
   92|  1.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.25k|         }
   94|  1.25k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_25with_connect_type_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.54M|      {
   88|  5.54M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.54M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.54M|         }
   91|  5.54M|         else {
   92|  5.54M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.54M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.54M|         }
   94|  5.54M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_25with_connect_type_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.85k|      {
   65|  4.85k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.85k|         return Action< Rule >::apply( action_input, st... );
   67|  4.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  18.1k|      {
   88|  18.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  18.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  18.1k|         }
   91|  18.1k|         else {
   92|  18.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.1k|         }
   94|  18.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  18.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  18.1k|      {
   88|  18.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  18.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  18.1k|         }
   91|  18.1k|         else {
   92|  18.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.1k|         }
   94|  18.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  18.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  18.1k|      {
   88|  18.1k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  18.1k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  18.1k|         }
   91|  18.1k|         else {
   92|  18.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.1k|         }
   94|  18.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  18.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5applyINS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  6.79k|      {
   65|  6.79k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.79k|         return Action< Rule >::apply( action_input, st... );
   67|  6.79k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  6.78k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.3k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   295k|      {
   88|   295k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   295k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   295k|         }
   91|   295k|         else {
   92|   295k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   295k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   295k|         }
   94|   295k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   295k|      {
   88|   295k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   295k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   295k|         }
   91|   295k|         else {
   92|   295k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   295k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   295k|         }
   94|   295k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   323k|      {
   88|   323k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   323k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   323k|         }
   91|   323k|         else {
   92|   323k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   323k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   323k|         }
   94|   323k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  6.76k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  6.76k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.43k|      {
   88|  6.43k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.43k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.43k|         }
   91|  6.43k|         else {
   92|  6.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.43k|         }
   94|  6.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.02k|      {
   88|  6.02k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.02k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.02k|         }
   91|  6.02k|         else {
   92|  6.02k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.02k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.02k|         }
   94|  6.02k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.82k|      {
   88|  5.82k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.82k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.82k|         }
   91|  5.82k|         else {
   92|  5.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.82k|         }
   94|  5.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.60k|      {
   88|  5.60k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.60k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.60k|         }
   91|  5.60k|         else {
   92|  5.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.60k|         }
   94|  5.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.08k|      {
   88|  5.08k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  5.08k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  5.08k|         }
   91|  5.08k|         else {
   92|  5.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.08k|         }
   94|  5.08k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.86k|      {
   65|  1.86k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.86k|         return Action< Rule >::apply( action_input, st... );
   67|  1.86k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.76k|      {
   88|  6.76k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.76k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.76k|         }
   91|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  7.71k|      {
   88|  7.71k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.71k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.71k|         }
   91|  7.71k|         else {
   92|  7.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.71k|         }
   94|  7.71k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.46k|      {
   88|  4.46k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.46k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.46k|         }
   91|  4.46k|         else {
   92|  4.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.46k|         }
   94|  4.46k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  4.46k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.32k|      {
   88|  4.32k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.32k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.32k|         }
   91|  4.32k|         else {
   92|  4.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.32k|         }
   94|  4.32k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   286k|      {
   88|   286k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   286k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   286k|         }
   91|   286k|         else {
   92|   286k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   286k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   286k|         }
   94|   286k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.25k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     38|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.25k|      {
   88|  3.25k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.25k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.25k|         }
   91|  3.25k|         else {
   92|  3.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.25k|         }
   94|  3.25k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.75k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  2.84k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   291k|      {
   88|   291k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   291k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   291k|         }
   91|   291k|         else {
   92|   291k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   291k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   291k|         }
   94|   291k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   291k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   291k|      {
   88|   291k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   291k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   291k|         }
   91|   291k|         else {
   92|   291k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   291k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   291k|         }
   94|   291k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   291k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   291k|      {
   88|   291k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   291k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   291k|         }
   91|   291k|         else {
   92|   291k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   291k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   291k|         }
   94|   291k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   291k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.24k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   290k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   291k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   291k|      {
   88|   291k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   291k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   291k|         }
   91|   291k|         else {
   92|   291k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   291k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   291k|         }
   94|   291k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   291k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   291k|      {
   88|   291k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   291k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   291k|         }
   91|   291k|         else {
   92|   291k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   291k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   291k|         }
   94|   291k|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   291k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   290k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.56k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   87|   290k|      {
   88|   290k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   290k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   290k|         }
   91|   290k|         else {
   92|   290k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   290k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   290k|         }
   94|   290k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   290k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  12.6M|      {
   88|  12.6M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  12.6M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  12.6M|         }
   91|  12.6M|         else {
   92|  12.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.6M|         }
   94|  12.6M|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  12.6M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  12.3M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   290k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   290k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   290k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.56k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   290k|      {
   88|   290k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   290k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   290k|         }
   91|   290k|         else {
   92|   290k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   290k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   290k|         }
   94|   290k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   290k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   290k|      {
   88|   290k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   290k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   290k|         }
   91|   290k|         else {
   92|   290k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   290k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   290k|         }
   94|   290k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   290k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   290k|      {
   88|   290k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   290k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   290k|         }
   91|   290k|         else {
   92|   290k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   290k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   290k|         }
   94|   290k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   290k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  35.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   254k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  35.6k|      {
   88|  35.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  35.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  35.6k|         }
   91|  35.6k|         else {
   92|  35.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.6k|         }
   94|  35.6k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  35.6k|      {
   88|  35.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  35.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  35.6k|         }
   91|  35.6k|         else {
   92|  35.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.6k|         }
   94|  35.6k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|  35.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  23.9M|      {
   88|  23.9M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.9M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.9M|         }
   91|  23.9M|         else {
   92|  23.9M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.9M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.9M|         }
   94|  23.9M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  23.9M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  35.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  23.8M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  23.8M|      {
   88|  23.8M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.8M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.8M|         }
   91|  23.8M|         else {
   92|  23.8M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.8M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.8M|         }
   94|  23.8M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  23.8M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  23.8M|      {
   88|  23.8M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.8M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.8M|         }
   91|  23.8M|         else {
   92|  23.8M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.8M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.8M|         }
   94|  23.8M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  23.8M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  23.8M|      {
   88|  23.8M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.8M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.8M|         }
   91|  23.8M|         else {
   92|  23.8M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.8M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.8M|         }
   94|  23.8M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   155k|      {
   88|   155k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   155k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   155k|         }
   91|   155k|         else {
   92|   155k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   155k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   155k|         }
   94|   155k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   155k|      {
   88|   155k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   155k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   155k|         }
   91|   155k|         else {
   92|   155k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   155k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   155k|         }
   94|   155k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   155k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   155k|      {
   88|   155k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   155k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   155k|         }
   91|   155k|         else {
   92|   155k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   155k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   155k|         }
   94|   155k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   155k|      {
   88|   155k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   155k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   155k|         }
   91|   155k|         else {
   92|   155k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   155k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   155k|         }
   94|   155k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  30.6k|      {
   88|  30.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.6k|         }
   91|  30.6k|         else {
   92|  30.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.6k|         }
   94|  30.6k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  30.6k|      {
   88|  30.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.6k|         }
   91|  30.6k|         else {
   92|  30.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.6k|         }
   94|  30.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  61.3k|      {
   88|  61.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  61.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  61.3k|         }
   91|  61.3k|         else {
   92|  61.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  61.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  61.3k|         }
   94|  61.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   124k|      {
   88|   124k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   124k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   124k|         }
   91|   124k|         else {
   92|   124k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   124k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   124k|         }
   94|   124k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   177k|      {
   88|   177k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   177k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   177k|         }
   91|   177k|         else {
   92|   177k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   177k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   177k|         }
   94|   177k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  45.0k|      {
   88|  45.0k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  45.0k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  45.0k|         }
   91|  45.0k|         else {
   92|  45.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0k|         }
   94|  45.0k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  45.0k|      {
   88|  45.0k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  45.0k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  45.0k|         }
   91|  45.0k|         else {
   92|  45.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0k|         }
   94|  45.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  79.9k|      {
   88|  79.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  79.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  79.9k|         }
   91|  79.9k|         else {
   92|  79.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  79.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  79.9k|         }
   94|  79.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    389|      {
   88|    389|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|    389|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|    389|         }
   91|    389|         else {
   92|    389|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    389|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    389|         }
   94|    389|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   155k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     52|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|     52|      {
   49|     52|#if defined( __cpp_exceptions )
   50|     52|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|     52|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   155k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_17condition_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  23.7M|      {
   88|  23.7M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  23.7M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  23.7M|         }
   91|  23.7M|         else {
   92|  23.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.7M|         }
   94|  23.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  23.8M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    272|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|  35.3k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|    272|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|    272|      {
   49|    272|#if defined( __cpp_exceptions )
   50|    272|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|    272|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  35.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   254k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   289k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5applyINS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   289k|      {
   65|   289k|         const typename ParseInput::action_t action_input( begin, in );
   66|   289k|         return Action< Rule >::apply( action_input, st... );
   67|   289k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   288k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.56k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  4.19k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    621|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.19k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.19k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.9k|      {
   88|  11.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  11.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  11.9k|         }
   91|  11.9k|         else {
   92|  11.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.9k|         }
   94|  11.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.9k|      {
   88|  11.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  11.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  11.9k|         }
   91|  11.9k|         else {
   92|  11.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.9k|         }
   94|  11.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.9k|      {
   88|  11.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  11.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  11.9k|         }
   91|  11.9k|         else {
   92|  11.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.9k|         }
   94|  11.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.36k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.60k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  10.5k|      {
   88|  10.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  10.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  10.5k|         }
   91|  10.5k|         else {
   92|  10.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.5k|         }
   94|  10.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  10.5k|      {
   88|  10.5k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  10.5k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  10.5k|         }
   91|  10.5k|         else {
   92|  10.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.5k|         }
   94|  10.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  25.3k|      {
   88|  25.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  25.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  25.3k|         }
   91|  25.3k|         else {
   92|  25.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.3k|         }
   94|  25.3k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS5_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.13k|      {
   88|  4.13k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.13k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.13k|         }
   91|  4.13k|         else {
   92|  4.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.13k|         }
   94|  4.13k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.88k|      {
   88|  3.88k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.88k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.88k|         }
   91|  3.88k|         else {
   92|  3.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.88k|         }
   94|  3.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|  3.65k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.65k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.65k|         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|  3.38k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  3.38k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  3.38k|         }
   91|  3.38k|         else {
   92|  3.38k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.38k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.38k|         }
   94|  3.38k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.94k|      {
   88|  2.94k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.94k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.94k|         }
   91|  2.94k|         else {
   92|  2.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.94k|         }
   94|  2.94k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyINS3_13label_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.63k|      {
   65|  1.63k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.63k|         return Action< Rule >::apply( action_input, st... );
   67|  1.63k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.34k|      {
   88|  4.34k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.34k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.34k|         }
   91|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.54k|      {
   88|  4.54k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.54k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.54k|         }
   91|  4.54k|         else {
   92|  4.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.54k|         }
   94|  4.54k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS4_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.30k|      {
   88|  2.30k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.30k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.30k|         }
   91|  2.30k|         else {
   92|  2.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.30k|         }
   94|  2.30k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.25k|      {
   88|  2.25k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.25k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.25k|         }
   91|  2.25k|         else {
   92|  2.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.25k|         }
   94|  2.25k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.59k|      {
   88|  4.59k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  4.59k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  4.59k|         }
   91|  4.59k|         else {
   92|  4.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.59k|         }
   94|  4.59k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.24k|      {
   88|  2.24k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  2.24k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  2.24k|         }
   91|  2.24k|         else {
   92|  2.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.24k|         }
   94|  2.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.56k|      {
   88|  7.56k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.56k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.56k|         }
   91|  7.56k|         else {
   92|  7.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.56k|         }
   94|  7.56k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.56k|      {
   88|  7.56k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.56k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.56k|         }
   91|  7.56k|         else {
   92|  7.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.56k|         }
   94|  7.56k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.50k|      {
   88|  6.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.50k|         }
   91|  6.50k|         else {
   92|  6.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.50k|         }
   94|  6.50k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS7_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  6.50k|      {
   88|  6.50k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  6.50k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  6.50k|         }
   91|  6.50k|         else {
   92|  6.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.50k|         }
   94|  6.50k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.35M|      {
   88|  7.35M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.35M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.35M|         }
   91|  7.35M|         else {
   92|  7.35M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.35M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.35M|         }
   94|  7.35M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|  7.34M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.34M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.34M|         }
   91|  7.34M|         else {
   92|  7.34M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.34M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.34M|         }
   94|  7.34M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|  7.34M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.34M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.34M|         }
   91|  7.34M|         else {
   92|  7.34M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.34M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.34M|         }
   94|  7.34M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|  7.34M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.34M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.34M|         }
   91|  7.34M|         else {
   92|  7.34M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.34M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.34M|         }
   94|  7.34M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS6_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   121k|      {
   88|   121k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   121k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   121k|         }
   91|   121k|         else {
   92|   121k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   121k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   121k|         }
   94|   121k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   121k|      {
   88|   121k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   121k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   121k|         }
   91|   121k|         else {
   92|   121k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   121k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   121k|         }
   94|   121k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   121k|      {
   88|   121k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   121k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   121k|         }
   91|   121k|         else {
   92|   121k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   121k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   121k|         }
   94|   121k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   121k|      {
   88|   121k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   121k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   121k|         }
   91|   121k|         else {
   92|   121k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   121k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   121k|         }
   94|   121k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  30.3k|      {
   88|  30.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.3k|         }
   91|  30.3k|         else {
   92|  30.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.3k|         }
   94|  30.3k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  30.3k|      {
   88|  30.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  30.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  30.3k|         }
   91|  30.3k|         else {
   92|  30.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.3k|         }
   94|  30.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  60.6k|      {
   88|  60.6k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  60.6k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  60.6k|         }
   91|  60.6k|         else {
   92|  60.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  60.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  60.6k|         }
   94|  60.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  90.7k|      {
   88|  90.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  90.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  90.7k|         }
   91|  90.7k|         else {
   92|  90.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  90.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  90.7k|         }
   94|  90.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   138k|      {
   88|   138k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|   138k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|   138k|         }
   91|   138k|         else {
   92|   138k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   138k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   138k|         }
   94|   138k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  33.3k|      {
   88|  33.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  33.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  33.3k|         }
   91|  33.3k|         else {
   92|  33.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.3k|         }
   94|  33.3k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  33.3k|      {
   88|  33.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  33.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  33.3k|         }
   91|  33.3k|         else {
   92|  33.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.3k|         }
   94|  33.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  57.3k|      {
   88|  57.3k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  57.3k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  57.3k|         }
   91|  57.3k|         else {
   92|  57.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  57.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  57.3k|         }
   94|  57.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2EN8usbguard10RuleParser13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.80k|      {
   88|  1.80k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  1.80k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  1.80k|         }
   91|  1.80k|         else {
   92|  1.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.80k|         }
   94|  1.80k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS3_13label_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.22M|      {
   88|  7.22M|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  7.22M|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  7.22M|         }
   91|  7.22M|         else {
   92|  7.22M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.22M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.22M|         }
   94|  7.22M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyINS3_13label_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  6.21k|      {
   65|  6.21k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.21k|         return Action< Rule >::apply( action_input, st... );
   67|  6.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.67k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.93k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.67k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.93k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  31.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.93k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15rule_attributesEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ENS9_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  28.7k|      {
   88|  28.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  28.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  28.7k|         }
   91|  28.7k|         else {
   92|  28.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.7k|         }
   94|  28.7k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ENS9_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  31.7k|      {
   88|  31.7k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  31.7k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  31.7k|         }
   91|  31.7k|         else {
   92|  31.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.7k|         }
   94|  31.7k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  28.5k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  5.59k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   40|  38.9k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ENS4_19rule_parser_actionsES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  38.9k|      {
   88|  38.9k|         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
  ------------------
  |  Branch (88:24): [Folded - Ignored]
  ------------------
   89|  38.9k|            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|  38.9k|         }
   91|  38.9k|         else {
   92|  38.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.9k|         }
   94|  38.9k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  38.9k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  38.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  38.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  4.31k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  39.0k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  4.31k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|  4.31k|      {
   49|  4.31k|#if defined( __cpp_exceptions )
   50|  4.31k|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|  4.31k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   40|  39.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  29.5k|      {}

_ZN3tao5pegtl5parseIN8usbguard10RuleParser12rule_grammarENS3_19rule_parser_actionsENS0_6normalELNS0_10apply_modeE1ELNS0_11rewind_modeE1ERNS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaOT4_DpOT5_:
   42|  38.3k|   {
   43|  38.3k|      return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   44|  38.3k|   }

_ZN3tao5pegtl8internal11parse_errorC2EPKc:
   32|  8.77k|         {}
_ZNK3tao5pegtl8internal11parse_error4whatEv:
   35|  8.77k|         {
   36|  8.77k|            return m_msg.c_str();
   37|  8.77k|         }
_ZNK3tao5pegtl8internal11parse_error9positionsEv:
   45|  8.77k|         {
   46|  8.77k|            return m_positions;
   47|  8.77k|         }
_ZN3tao5pegtl8internal11parse_error12add_positionEONS0_8positionE:
   50|  8.77k|         {
   51|  8.77k|            const auto prefix = to_string( p );
   52|  8.77k|            m_msg = prefix + ": " + m_msg;
   53|  8.77k|            m_prefix += prefix.size() + 2;
   54|  8.77k|            m_positions.emplace_back( std::move( p ) );
   55|  8.77k|         }
_ZN3tao5pegtl11parse_errorC2EPKcNS0_8positionE:
   70|  8.77k|      {
   71|  8.77k|         m_impl->add_position( std::move( p ) );
   72|  8.77k|      }
_ZN3tao5pegtl11parse_errorC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_8positionE:
   76|  6.72k|      {}
_ZNK3tao5pegtl11parse_error4whatEv:
   89|  8.77k|      {
   90|  8.77k|         return m_impl->what();
   91|  8.77k|      }
_ZNK3tao5pegtl11parse_error9positionsEv:
   99|  8.77k|      {
  100|  8.77k|         return m_impl->positions();
  101|  8.77k|      }
_ZN3tao5pegtl11parse_errorC2INS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEEERKSE_RKT_:
   86|  6.72k|      {}
_ZN3tao5pegtl11parse_errorC2INS0_8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEEEPKcRKT_:
   81|  2.05k|      {}

_ZN3tao5pegtl8positionC2EOS1_:
   32|  15.4k|      {}
_ZN3tao5pegtllsERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERKNS0_8positionE:
   85|  8.77k|   {
   86|  8.77k|      return os << p.source << ':' << p.line << ':' << p.column;
   87|  8.77k|   }
_ZN3tao5pegtl9to_stringERKNS0_8positionE:
   90|  8.77k|   {
   91|  8.77k|      std::ostringstream oss;
   92|  8.77k|      oss << p;
   93|  8.77k|      return std::move( oss ).str();
   94|  8.77k|   }
_ZN3tao5pegtl8positionC2IRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKNS0_8internal8iteratorEOT_:
   56|  8.77k|      {}
_ZN3tao5pegtl8positionD2Ev:
   66|  24.2k|      ~position() = default;

_ZN3tao5pegtl12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEED2Ev:
   53|  38.3k|      ~string_input() = default;
_ZN3tao5pegtl8internal13string_holderD2Ev:
   31|  38.3k|         ~string_holder() = default;
_ZN3tao5pegtl12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEC2IRKSC_SG_JEEEOT_OT0_DpOT1_:
   48|  38.3k|      {}
_ZN3tao5pegtl8internal13string_holderC2IRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_:
   26|  38.3k|         {}